@shanepadgett/tau-agent 0.29.0 → 0.30.0

package/extensions/working-memory/index.ts

@@ -174,14 +174,32 @@ export default function workingMemoryExtension(pi: ExtensionAPI): void {
 		syncBranch(ctx);
 	});
 
-	pi.on("before_agent_start", (event, ctx) => {
+	pi.on("before_agent_start", (_event, ctx) => {
 		if (!enabled) return undefined;
 		const usage = ctx.getContextUsage();
 		if (!usage || usage.tokens === null || !Number.isFinite(usage.tokens)) return undefined;
-		const reminder = Math.floor(Math.max(0, usage.tokens) / interval);
+		const tokens = Math.max(0, Math.floor(usage.tokens));
+		const reminder = Math.floor(tokens / interval);
 		if (reminder < 1) return undefined;
 		const instruction = instructions[Math.min(reminder, instructions.length) - 1] ?? instructions[0];
-		return { systemPrompt: `${event.systemPrompt}\n\n${automaticInstruction(instruction)}` };
+		return {
+			message: {
+				customType: NUDGE_TYPE,
+				content: automaticInstruction(instruction),
+				display: false,
+				details: {
+					v: 1,
+					kind: "automatic",
+					tokens,
+					boundaryTokens: reminder * interval,
+					reminder,
+					tier: Math.min(reminder, instructions.length),
+					tierCount: instructions.length,
+					anchorToolCallId:
+						replayWorkingMemoryState(ctx.sessionManager.getBranch(), true).latestAnchorToolCallId ?? null,
+				},
+			},
+		};
 	});
 
 	pi.on("turn_end", (event, ctx) => {

package/extensions/working-memory/memory.ts

@@ -1,4 +1,5 @@
 import { sessionEntryToContextMessages, type ContextEvent, type SessionEntry } from "@earendil-works/pi-coding-agent";
+import { isContextProjectionMessage, isLegacyContextMessage } from "../../shared/context-messages.ts";
 import type { ActiveWorkingMemoryState } from "./state.ts";
 
 type ContextMessage = ContextEvent["messages"][number];
@@ -67,6 +68,14 @@ export function buildMemoryCatalog(branch: readonly SessionEntry[]): Map<string,
 		}
 		if (message.role === "toolResult") continue;
 		if (message.role === "custom" && EXCLUDED_CUSTOM_TYPES.has(message.customType)) continue;
+		if (
+			message.role === "custom" &&
+			message.customType === "tau.injected-context" &&
+			message.details &&
+			typeof message.details === "object" &&
+			(message.details as Record<string, unknown>).source === "context"
+		)
+			continue;
 		const ref = `m:${entry.id}`;
 		catalog.set(ref, {
 			ref,
@@ -121,20 +130,29 @@ function referenceCurrentMessages(
 	entries: readonly SessionEntry[],
 	catalog: ReadonlyMap<string, MemoryUnit>,
 ): MemoryUnit[][] {
-	const generated = entries.flatMap((entry) =>
-		sessionEntryToContextMessages(entry).map((message) => ({ entry, message })),
+	const generated = entries
+		.flatMap((entry) => sessionEntryToContextMessages(entry).map((message) => ({ entry, message })))
+		.filter(({ message }) => !isLegacyContextMessage(message));
+	const sessionMessages = messages.filter(
+		(message) => !isContextProjectionMessage(message) && !isLegacyContextMessage(message),
 	);
-	if (generated.length !== messages.length) return messages.map(() => []);
+	if (generated.length !== sessionMessages.length) return messages.map(() => []);
 	const toolRefs = new Map<string, MemoryUnit[]>();
 	for (const unit of catalog.values()) {
 		const result = unit.messages.find((message) => message.role === "toolResult");
 		if (result?.role !== "toolResult") continue;
 		toolRefs.set(result.toolCallId, [...(toolRefs.get(result.toolCallId) ?? []), unit]);
 	}
-	return generated.map(({ entry, message }, index) => {
+	let generatedIndex = 0;
+	return messages.map((currentMessage) => {
+		if (isContextProjectionMessage(currentMessage) || isLegacyContextMessage(currentMessage)) return [];
+		const current = generated[generatedIndex];
+		generatedIndex += 1;
+		if (!current) return [];
+		const { entry, message } = current;
 		if (message.role === "assistant") {
 			const unit = catalog.get(`m:${entry.id}`);
-			return unit && messages[index]?.role === "assistant" ? [unit] : [];
+			return unit && currentMessage.role === "assistant" ? [unit] : [];
 		}
 		if (message.role === "toolResult") return toolRefs.get(message.toolCallId) ?? [];
 		const unit = catalog.get(`m:${entry.id}`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.29.0",
+	"version": "0.30.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.0",
-		"@shanepadgett/tau-tui": "0.29.0",
+		"@shanepadgett/tau-tui": "0.30.0",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
 		"smol-toml": "1.7.0",

package/schemas/tau.schema.json

@@ -248,31 +248,17 @@
 					},
 					"additionalProperties": false
 				},
-				"turnBudget": {
+				"subagent": {
 					"type": "object",
 					"properties": {
-						"enabled": {
-							"type": "boolean",
-							"default": true,
-							"description": "Enable turn-budget hints."
-						},
-						"turnLimit": {
-							"type": "integer",
-							"default": 30,
-							"minimum": 1,
-							"description": "Initial soft cap for tool-using turns per user prompt."
-						},
-						"nudgeEveryTurns": {
-							"type": "integer",
-							"default": 5,
-							"minimum": 1,
-							"description": "Tool-using turn interval between turn-budget hints."
-						},
-						"softCapIncrement": {
-							"type": "integer",
-							"default": 10,
-							"minimum": 1,
-							"description": "Turns added when the soft cap is reached."
+						"disabled": {
+							"type": "array",
+							"items": {
+								"type": "string",
+								"minLength": 1
+							},
+							"default": [],
+							"description": "Agent names unavailable for delegation."
 						}
 					},
 					"additionalProperties": false

package/shared/context-messages.ts

@@ -0,0 +1,19 @@
+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/injected-context.ts

@@ -3,7 +3,7 @@ import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 export const INJECTED_CONTEXT_TYPE = "tau.injected-context";
 
 export interface InjectedContextDetails {
-	source: "review" | "context";
+	source: "review";
 	title?: string;
 }
 
@@ -61,7 +61,7 @@ export function getBranchInjectedContexts(entries: readonly SessionEntry[]): Inj
 function readDetails(value: unknown): InjectedContextDetails | undefined {
 	if (!value || typeof value !== "object") return undefined;
 	const record = value as Record<string, unknown>;
-	if (record.source !== "review" && record.source !== "context") return undefined;
+	if (record.source !== "review") return undefined;
 	return {
 		source: record.source,
 		...(typeof record.title === "string" ? { title: record.title } : {}),

package/shared/isolated-session.ts

@@ -0,0 +1,151 @@
+import {
+	createAgentSession,
+	DefaultResourceLoader,
+	getAgentDir,
+	ModelRuntime,
+	SessionManager,
+	type AgentSession,
+	type ExtensionContext,
+	type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+
+type IsolatedSessionThinkingLevel = NonNullable<ExtensionContext["thinkingLevel"]>;
+
+type SelectedModel = NonNullable<ExtensionContext["model"]>;
+type SelectedProvider = NonNullable<ReturnType<ExtensionContext["modelRegistry"]["getProvider"]>>;
+
+export interface IsolatedSessionInputs {
+	label: string;
+	extensionPaths: readonly string[];
+	cwd: string;
+	model: SelectedModel;
+	provider: SelectedProvider;
+	runtimeApiKey: string | undefined;
+	thinkingLevel: IsolatedSessionThinkingLevel;
+	tools: readonly string[];
+	customTools: readonly ToolDefinition[];
+	bindTarget: { mode: "print" } | { mode: "tui"; uiContext: ExtensionContext["ui"] };
+}
+
+export interface IsolatedSessionResource {
+	readonly session: AgentSession;
+	dispose(): Promise<void>;
+}
+
+export async function resolveIsolatedSessionModel(options: {
+	label: string;
+	preferredModel: string | undefined;
+	preferredThinkingLevel: IsolatedSessionThinkingLevel | undefined;
+	usePreferredThinkingAfterModelFallback: boolean;
+	ctx: ExtensionContext;
+	parentThinkingLevel: IsolatedSessionThinkingLevel;
+	signal: AbortSignal;
+	onWarning?: (warning: string) => void;
+}): Promise<Pick<IsolatedSessionInputs, "model" | "provider" | "runtimeApiKey" | "thinkingLevel">> {
+	const { ctx, signal, onWarning } = options;
+	let model = ctx.model;
+	let thinkingLevel = options.parentThinkingLevel;
+	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;
+			}
+		}
+	}
+	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;
+	}
+	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}`);
+	const provider = ctx.modelRegistry.getProvider(model.provider);
+	if (!provider) throw new Error(`${options.label} startup failed: provider ${model.provider} is unavailable`);
+	if (signal.aborted) throw new Error(`${options.label} startup aborted`);
+	return {
+		model,
+		provider,
+		runtimeApiKey:
+			auth.apiKey && provider.auth.apiKey && !ctx.modelRegistry.isUsingOAuth(model) ? auth.apiKey : undefined,
+		thinkingLevel,
+	};
+}
+
+export async function createIsolatedSessionResource(
+	inputs: IsolatedSessionInputs,
+	signal: AbortSignal,
+): Promise<IsolatedSessionResource> {
+	let session: AgentSession | undefined;
+	try {
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const modelRuntime = await ModelRuntime.create();
+		modelRuntime.registerNativeProvider(inputs.provider);
+		if (inputs.runtimeApiKey !== undefined)
+			await modelRuntime.setRuntimeApiKey(inputs.model.provider, inputs.runtimeApiKey, { allowNetwork: false });
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const resourceLoader = new DefaultResourceLoader({
+			cwd: inputs.cwd,
+			agentDir: getAgentDir(),
+			noExtensions: true,
+			additionalExtensionPaths: [...inputs.extensionPaths],
+		});
+		await resourceLoader.reload();
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const created = await createAgentSession({
+			cwd: inputs.cwd,
+			model: inputs.model,
+			modelRuntime,
+			thinkingLevel: inputs.thinkingLevel,
+			tools: [...inputs.tools],
+			excludeTools: ["subagent"],
+			resourceLoader,
+			customTools: [...inputs.customTools],
+			sessionManager: SessionManager.inMemory(inputs.cwd),
+		});
+		session = created.session;
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		await session.bindExtensions(inputs.bindTarget);
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const active = session.getActiveToolNames().sort();
+		const expected = [...inputs.tools].sort();
+		if (active.join("\0") !== expected.join("\0") || active.includes("subagent")) {
+			const missing = expected.filter((tool) => !active.includes(tool));
+			throw new Error(
+				`${inputs.label} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,
+			);
+		}
+		let disposed = false;
+		return {
+			session,
+			async dispose() {
+				if (disposed) return;
+				disposed = true;
+				if (session?.isStreaming) await session.abort().catch(() => undefined);
+				session?.dispose();
+			},
+		};
+	} catch (error) {
+		if (session?.isStreaming) await session.abort().catch(() => undefined);
+		session?.dispose();
+		throw error;
+	}
+}

package/extensions/subagent/agents/review.md

@@ -1,75 +0,0 @@
----
-name: review
-description: Perform a nuclear, architecture-first review for necessity, reuse, ownership, duplication, and simplification; runtime correctness is secondary
-tools:
-  - read
-  - bash
-  - outline
-  - show
-  - discover
-  - ast_search
-  - deps
-  - reverse_deps
-  - callers
-  - callees
-  - references
-  - implementations
-  - impact
-  - context
-names:
-  - Auditor
-  - Inspector
-  - Skeptic
-  - Examiner
-  - Sentinel
-model: openai-codex/gpt-5.6-sol
-thinking: high
----
-
-Stay centered on delegated change, but inspect enough surrounding code to find correct ownership and existing reuse. Every review is a nuclear review of codebase health. A caller may narrow changed behavior under review; it cannot reduce review to runtime correctness.
-
-Answer in this order:
-
-1. Should this code exist? Is every added behavior requested and necessary?
-2. Does repository code, stdlib, platform, or an installed dependency already solve it?
-3. Is logic owned by right layer and fixed at shared root rather than patched at one symptom or caller?
-4. Does change leave codebase smaller and more coherent than other credible implementations?
-5. Is runtime behavior correct?
-
-Find concrete architectural damage, missed simplifications, and failures. Report. Stop. No mutations, unrelated repository archaeology, or broad concern inventory.
-
-## Evidence ladder
-
-Use cheapest evidence that settles each tier. Escalate only when answer could change verdict.
-
-1. **Supplied context** — Treat current line-numbered task files as authoritative this turn.
-2. **Paths and literals** — Use read-only `bash` (`ls`, `find`, `rg`/`grep`) for narrow path discovery, exact text, registrations, and unsupported formats. Use ranged `read` when formatting or source context matters.
-3. **Structure, ownership, and reuse** — Default to `outline`. Use `discover` when changed code may duplicate an existing repository API but name or path is unknown. Use `ast_search` for a concrete duplicated shape, parallel concept, misplaced responsibility, or risky source shape.
-4. **Exact declarations** — Use `show` with path + name (+ line when needed). Retrieve only contract, body, imports, or nearby lines needed for verdict.
-5. **Relationships and runtime** — Use `callers`, `callees`, `references`, or `implementations` after selecting a declaration. Use `deps`/`reverse_deps` for file ownership and imports. Use `impact` for full blast radius and `context` for one bounded declaration pack.
-
-Keep roots and result limits narrow. Structural evidence proves bounded syntax, not dynamic dispatch. Preserve inferred and ambiguous labels.
-
-## Review procedure
-
-Run every tier in order, even when caller asks only for runtime review:
-
-1. **Necessity and scope** — Extract requested behavior and repository constraints. Identify speculative behavior, bonus surfaces, configuration, or staging that can disappear.
-2. **Reuse** — Search for existing helpers, types, components, patterns, stdlib, platform features, and installed dependencies before accepting new code.
-3. **Ownership and architecture** — Check whether change belongs in current layer, fixes shared root, preserves one source of truth, and avoids parallel concepts. Follow callers and sibling paths when needed to detect a local symptom patch.
-4. **Codebase health** — Look for duplication, fragmented ownership, wrappers, option bags, helpers, files, types, and abstractions whose removal materially reduces concepts. Consider a focused refactor when local patch deepens bad structure.
-5. **Runtime correctness** — Spend remaining effort on shortest realistic path through state transitions, boundaries, error handling, and affected callers. Avoid theoretical branch inventory.
-6. Stop when every tier has enough evidence for verdict.
-
-Treat every added concept as guilty until evidence justifies it. Reject speculation, personal style preferences, and architecture complaints without concrete ownership, maintenance, duplication, or change-cost impact. Do not modify files.
-
-## Output
-
-List architectural findings first, then runtime findings. Order each group by severity. Each finding needs:
-
-- severity and direct title;
-- exact file, line range, and declaration when one exists;
-- failure mechanism or concrete architectural cost;
-- smallest credible fix direction.
-
-Then list only unresolved questions that materially affect verdict. No findings: say architecture, reuse, and scope look healthy, implementation is simplest credible version, and runtime appears correct. Briefly name inspected scope. No preamble, search log, broad summary, or repeated evidence.

package/extensions/turn-budget/README.md

@@ -1,14 +0,0 @@
-# Turn Budget
-
-Adds soft turn budget hints for Tau sessions.
-
-Turn Budget helps agents spend fewer provider cycles by nudging them to batch related tool work. It counts
-tool-using turns per user prompt, sends visible steering messages at configured intervals, and extends the soft cap
-instead of blocking work.
-
-## Settings
-
-- `enabled`: defaults to `true`
-- `turnLimit`: defaults to `30`
-- `nudgeEveryTurns`: defaults to `5`
-- `softCapIncrement`: defaults to `10`

package/extensions/turn-budget/index.ts

@@ -1,116 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { Marker } from "@shanepadgett/tau-tui";
-import turnBudgetSettings from "./settings.ts";
-
-const MARKER_TYPE = "tau.turn-budget.marker";
-
-interface Settings {
-	enabled: boolean;
-	turnLimit: number;
-	nudgeEveryTurns: number;
-	softCapIncrement: number;
-}
-
-type Hint =
-	| { kind: "normal"; used: number; cap: number }
-	| { kind: "extended"; used: number; previousCap: number; newCap: number };
-
-interface MarkerDetails {
-	used: number;
-	cap: number;
-	extended: boolean;
-}
-
-export default function turnBudgetExtension(pi: ExtensionAPI): void {
-	let settings = normalizeSettings(turnBudgetSettings.defaults);
-	let turnCount = 0;
-	let softCap = settings.turnLimit;
-
-	pi.registerMessageRenderer<MarkerDetails>(MARKER_TYPE, (message, _options, theme) => {
-		const details = readMarkerDetails(message.details);
-		if (!details) return undefined;
-		return new Marker({
-			theme,
-			state: "muted",
-			label: "Turn Budget:",
-			parts: [`${details.used}/${details.cap}`, ...(details.extended ? ["Soft cap extended."] : [])],
-		});
-	});
-
-	pi.on("session_start", async (_event, ctx) => {
-		settings = normalizeSettings(await loadTauExtensionSettings(ctx, turnBudgetSettings));
-	});
-
-	pi.on("agent_start", () => {
-		turnCount = 0;
-		softCap = settings.turnLimit;
-	});
-
-	pi.on("turn_end", (event) => {
-		if (!settings.enabled) return undefined;
-		if (event.toolResults.length === 0) return undefined;
-		turnCount += 1;
-		if (turnCount >= softCap) {
-			const hint: Hint = {
-				kind: "extended",
-				used: turnCount,
-				previousCap: softCap,
-				newCap: turnCount + settings.softCapIncrement,
-			};
-			sendTurnBudgetMessage(pi, hint);
-			softCap = hint.newCap;
-			return undefined;
-		}
-		if (turnCount % settings.nudgeEveryTurns === 0) {
-			const hint: Hint = { kind: "normal", used: turnCount, cap: softCap };
-			sendTurnBudgetMessage(pi, hint);
-		}
-		return undefined;
-	});
-}
-
-function sendTurnBudgetMessage(pi: ExtensionAPI, hint: Hint): void {
-	pi.sendMessage<MarkerDetails>({
-		customType: MARKER_TYPE,
-		content: formatSteeringMessage(hint),
-		display: true,
-		details: markerDetails(hint),
-	});
-}
-
-function formatSteeringMessage(hint: Hint): string {
-	const instruction =
-		"Internal steering instruction. Work within it silently. Do not mention or acknowledge turn counts, budget messages, or budget summaries.";
-	if (hint.kind === "extended") {
-		return `${instruction} Turn budget: ${hint.used}/${hint.previousCap} turns used for this user prompt. Soft cap extended to ${hint.newCap}. Batch tools when more tool work remains.`;
-	}
-	return `${instruction} Turn budget: ${hint.used}/${hint.cap} turns used for this user prompt. Batch tools when more tool work remains.`;
-}
-
-function normalizeSettings(value: typeof turnBudgetSettings.defaults): Settings {
-	return {
-		enabled: value.enabled ?? true,
-		turnLimit: Number.isInteger(value.turnLimit) && value.turnLimit > 0 ? value.turnLimit : 30,
-		nudgeEveryTurns: Number.isInteger(value.nudgeEveryTurns) && value.nudgeEveryTurns > 0 ? value.nudgeEveryTurns : 5,
-		softCapIncrement:
-			Number.isInteger(value.softCapIncrement) && value.softCapIncrement > 0 ? value.softCapIncrement : 10,
-	};
-}
-
-function markerDetails(hint: Hint): MarkerDetails {
-	return hint.kind === "extended"
-		? { used: hint.used, cap: hint.newCap, extended: true }
-		: { used: hint.used, cap: hint.cap, extended: false };
-}
-
-function readMarkerDetails(value: unknown): MarkerDetails | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const record = value as Record<string, unknown>;
-	const used = record.used;
-	const cap = record.cap;
-	if (typeof used !== "number" || !Number.isInteger(used) || used < 0) return undefined;
-	if (typeof cap !== "number" || !Number.isInteger(cap) || cap < 1) return undefined;
-	if (typeof record.extended !== "boolean") return undefined;
-	return { used, cap, extended: record.extended };
-}

package/extensions/turn-budget/settings.ts

@@ -1,35 +0,0 @@
-import { Type } from "typebox";
-import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
-
-export default defineTauExtensionSettings({
-	key: "turnBudget",
-	defaults: {
-		enabled: true as boolean,
-		turnLimit: 30 as number,
-		nudgeEveryTurns: 5 as number,
-		softCapIncrement: 10 as number,
-	},
-	schema: Type.Object(
-		{
-			enabled: Type.Optional(Type.Boolean({ default: true, description: "Enable turn-budget hints." })),
-			turnLimit: Type.Optional(
-				Type.Integer({
-					default: 30,
-					minimum: 1,
-					description: "Initial soft cap for tool-using turns per user prompt.",
-				}),
-			),
-			nudgeEveryTurns: Type.Optional(
-				Type.Integer({
-					default: 5,
-					minimum: 1,
-					description: "Tool-using turn interval between turn-budget hints.",
-				}),
-			),
-			softCapIncrement: Type.Optional(
-				Type.Integer({ default: 10, minimum: 1, description: "Turns added when the soft cap is reached." }),
-			),
-		},
-		{ additionalProperties: false },
-	),
-});