@namzu/sdk 35.0.0 → 37.0.0

package/src/tools/builtins/run-code.ts

@@ -49,6 +49,12 @@ export interface RunCodeToolOptions {
 	readonly runtime?: CodeRuntime
 	readonly timeoutMs?: number
 	readonly maxOutputBytes?: number
+	/**
+	 * What a successful `call()` resolves to. Default: `text` (ToolResult.output).
+	 * `structured` returns `{ output, data? }`, preserving JSON tool data for
+	 * local filtering. Failures still reject; authority and dispatch are unchanged.
+	 */
+	readonly toolResultMode?: 'text' | 'structured'
 }
 
 const DEFAULT_TIMEOUT_MS = 30_000
@@ -59,8 +65,11 @@ export function buildRunCodeTool(options: RunCodeToolOptions = {}) {
 
 	return defineTool({
 		name: RUN_CODE_TOOL_NAME,
-		description:
-			"Runs a short JavaScript program that can call this run's own tools in a loop. Use it when the same tool would otherwise be called many times in a row — filtering, retrying, fanning out — and not for a single call.",
+		description: `Runs a short JavaScript program that can call this run's own tools in a loop. Use it when the same tool would otherwise be called many times in a row — filtering, retrying, fanning out — and not for a single call. ${
+			options.toolResultMode === 'structured'
+				? 'Each successful call() returns { output: string, data?: JSON value }. Filter data locally and return only the needed result. Failed calls reject.'
+				: 'Each successful call() returns the tool output string. Failed calls reject.'
+		}`,
 		inputSchema,
 		category: 'custom',
 		permissions: [],
@@ -108,9 +117,19 @@ export function buildRunCodeTool(options: RunCodeToolOptions = {}) {
 							signal: operation.signal,
 							runtimeToolCallId: operation.runtimeToolCallId,
 						})
-						return toolResult.success
-							? { ok: true, value: toolResult.output }
-							: { ok: false, error: toolResult.error ?? 'the tool failed' }
+						if (!toolResult.success) {
+							return { ok: false, error: toolResult.error ?? 'the tool failed' }
+						}
+						return {
+							ok: true,
+							value:
+								options.toolResultMode === 'structured'
+									? {
+											output: toolResult.output,
+											...(toolResult.data !== undefined ? { data: toolResult.data } : {}),
+										}
+									: toolResult.output,
+						}
 					} catch (err) {
 						return {
 							ok: false,

package/src/tools/builtins/search-tools.ts

@@ -38,8 +38,7 @@ export const SearchToolsTool = defineTool({
 			}
 		}
 
-		const allowed =
-			context.allowedTools && context.allowedTools.length > 0 ? new Set(context.allowedTools) : null
+		const allowed = context.allowedTools !== undefined ? new Set(context.allowedTools) : null
 		// `searchDeferred` returns a ranked list (score-descending), so slicing
 		// the head is a true top-k activation, not an arbitrary subset.
 		const ranked = context.toolRegistry
@@ -47,9 +46,25 @@ export const SearchToolsTool = defineTool({
 			.filter((tool) => !allowed || allowed.has(tool.name))
 
 		if (ranked.length === 0) {
+			const active = context.toolRegistry
+				.searchActive?.(input.query)
+				.filter(
+					(tool) =>
+						(!allowed || allowed.has(tool.name)) &&
+						context.toolRegistry?.getAvailability(tool.name) === 'active',
+				)
+			const activeReceipt =
+				active === undefined
+					? 'This registry cannot search active tools.'
+					: active.length === 0
+						? 'No matching active tools were found.'
+						: `Already active matching tools (up to ${ACTIVATION_TOP_K}):\n${active
+								.slice(0, ACTIVATION_TOP_K)
+								.map((tool) => `- ${tool.name}`)
+								.join('\n')}`
 			return {
 				success: true,
-				output: `No deferred tools matching "${input.query}". All matching tools are already active.`,
+				output: `No deferred tools matching "${input.query}". ${activeReceipt}`,
 			}
 		}
 

package/src/tools/defineTool.ts

@@ -20,6 +20,8 @@ export interface DefineToolOptions<S extends z.ZodType> {
 	readOnly: boolean
 	destructive: boolean | ((input: z.infer<S>) => boolean)
 	concurrencySafe: boolean
+	/** Batch ordering boundary; see {@link ToolDefinition.executionBarrier}. */
+	executionBarrier?: boolean
 	tier?: string
 	/**
 	 * How this tool's call and result should be shown; see
@@ -81,6 +83,9 @@ export function defineTool<S extends z.ZodType>(
 		...(options.presentResult ? { presentResult: options.presentResult } : {}),
 		...(options.outputSchema !== undefined ? { outputSchema: options.outputSchema } : {}),
 		...(options.terminal !== undefined ? { terminal: options.terminal } : {}),
+		...(options.executionBarrier !== undefined
+			? { executionBarrier: options.executionBarrier }
+			: {}),
 		category: options.category,
 		permissions: options.permissions,
 		isReadOnly: () => options.readOnly,

package/src/tools/memory/delete.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod'
+import type { MemoryStore } from '../../types/memory/index.js'
+import type { ToolDefinition } from '../../types/tool/index.js'
+import { asMemoryId } from '../../utils/id.js'
+import { defineTool } from '../defineTool.js'
+
+export function buildDeleteMemoryTool(store: MemoryStore): ToolDefinition {
+	return defineTool({
+		name: 'delete_memory',
+		description:
+			'Permanently delete a stored memory by ID. Use update_memory with status archived when the record should remain available for inspection. Deletion does not erase past conversation transcripts.',
+		inputSchema: z.object({
+			id: z.string().describe('Memory ID to permanently delete'),
+		}),
+		category: 'custom',
+		permissions: [],
+		readOnly: false,
+		destructive: true,
+		concurrencySafe: true,
+		async execute({ id }) {
+			const removed = await store.delete(asMemoryId(id))
+			return {
+				success: removed,
+				output: removed ? `Memory deleted: ${id}.` : `Memory ${id} not found.`,
+				...(removed ? {} : { error: 'Memory not found' }),
+			}
+		},
+	})
+}

package/src/tools/memory/index.ts

@@ -1,8 +1,10 @@
 import type { MemoryIndex, MemoryStore } from '../../types/memory/index.js'
 import type { ToolDefinition } from '../../types/tool/index.js'
+import { buildDeleteMemoryTool } from './delete.js'
 import { buildReadMemoryTool } from './read.js'
 import { buildSaveMemoryTool } from './save.js'
 import { buildSearchMemoryTool, buildStoreSearchMemoryTool } from './search.js'
+import { buildUpdateMemoryTool } from './update.js'
 
 /**
  * Build memory tools over one authoritative store.
@@ -28,9 +30,13 @@ export function buildMemoryTools(store: MemoryStore, index?: MemoryIndex): ToolD
 		index ? buildSearchMemoryTool(index) : buildStoreSearchMemoryTool(store),
 		buildReadMemoryTool(store),
 		buildSaveMemoryTool(store),
+		buildUpdateMemoryTool(store),
+		buildDeleteMemoryTool(store),
 	]
 }
 
 export { buildSearchMemoryTool } from './search.js'
 export { buildReadMemoryTool } from './read.js'
 export { buildSaveMemoryTool } from './save.js'
+export { buildUpdateMemoryTool } from './update.js'
+export { buildDeleteMemoryTool } from './delete.js'

package/src/tools/memory/save.ts

@@ -6,7 +6,8 @@ import { defineTool } from '../defineTool.js'
 export function buildSaveMemoryTool(store: MemoryStore): ToolDefinition {
 	return defineTool({
 		name: 'save_memory',
-		description: 'Save a new memory with title, summary, and full content for future reference.',
+		description:
+			'Save a new historical claim for future reference. Include the actual useful fact and its evidence in the summary and content. For corrections to an existing record use update_memory instead of creating contradictory duplicates.',
 		inputSchema: z.object({
 			title: z.string().min(1).describe('Short descriptive title'),
 			summary: z.string().min(1).describe('Brief summary (1-2 sentences)'),
@@ -18,12 +19,13 @@ export function buildSaveMemoryTool(store: MemoryStore): ToolDefinition {
 		readOnly: false,
 		destructive: false,
 		concurrencySafe: true,
-		async execute({ title, summary, content, tags }) {
+		async execute({ title, summary, content, tags }, context) {
 			const { entry } = await store.create({
 				title,
 				summary,
 				content,
 				tags,
+				metadata: { source: 'agent-memory', runId: context.runId },
 			})
 
 			return {

package/src/tools/memory/search.ts

@@ -14,19 +14,26 @@ function defineSearchMemoryTool(search: SearchMemory): ToolDefinition {
 	return defineTool({
 		name: 'search_memory',
 		description:
-			'Search stored memories by query, tags, or status. Returns titles and summaries only — use read_memory for full content.',
+			'Search active stored memories by relevant words or tags. The built-in store ranks matches in titles, summaries and full content. Returns titles and summaries; use read_memory for evidence. Set status to archived to inspect obsolete records.',
 		inputSchema: z.object({
-			query: z.string().optional().describe('Search query to match against titles and summaries'),
+			query: z.string().optional().describe('Relevant words or identifiers to search'),
 			tags: z.array(z.string()).optional().describe('Filter by tags (all must match)'),
-			limit: z.number().positive().default(10).describe('Maximum results to return'),
+			status: z.enum(['active', 'archived']).default('active'),
+			limit: z
+				.number()
+				.int()
+				.min(1)
+				.max(50)
+				.default(10)
+				.describe('Maximum results to return (1–50)'),
 		}),
 		category: 'analysis',
 		permissions: [],
 		readOnly: true,
 		destructive: false,
 		concurrencySafe: true,
-		async execute({ query, tags, limit }) {
-			const result = await search({ query, tags, limit })
+		async execute({ query, tags, status, limit }) {
+			const result = await search({ query, tags, status, limit })
 
 			if (result.entries.length === 0) {
 				return {

package/src/tools/memory/update.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+import type { MemoryStore } from '../../types/memory/index.js'
+import type { ToolDefinition } from '../../types/tool/index.js'
+import { asMemoryId } from '../../utils/id.js'
+import { defineTool } from '../defineTool.js'
+
+export function buildUpdateMemoryTool(store: MemoryStore): ToolDefinition {
+	return defineTool({
+		name: 'update_memory',
+		description:
+			'Correct an existing memory in place, or archive an obsolete claim so it is no longer recalled. Use the ID from search_memory; current evidence should determine corrections.',
+		inputSchema: z.object({
+			id: z.string().describe('Memory ID to correct or archive'),
+			title: z.string().min(1).optional(),
+			summary: z.string().min(1).optional(),
+			content: z.string().min(1).optional(),
+			tags: z.array(z.string()).optional(),
+			status: z.enum(['active', 'archived']).optional(),
+		}),
+		category: 'custom',
+		permissions: [],
+		readOnly: false,
+		destructive: false,
+		concurrencySafe: true,
+		async execute({ id, ...updates }) {
+			if (Object.values(updates).every((value) => value === undefined)) {
+				return {
+					success: false,
+					output: 'Provide a correction or status to update.',
+					error: 'No memory update supplied',
+				}
+			}
+			const memoryId = asMemoryId(id)
+			// Patch only requested fields in one store operation. A read/merge of
+			// provenance here would overwrite metadata from a concurrent writer.
+			const entry = await store.update(memoryId, updates)
+			if (!entry)
+				return {
+					success: false,
+					output: `Memory ${id} no longer exists.`,
+					error: 'Memory not found',
+				}
+			return {
+				success: true,
+				output: `Memory updated: ${id} — ${entry.title} (${entry.status}).`,
+				data: { id, status: entry.status },
+			}
+		},
+	})
+}

package/src/types/agent/scheduler.ts

@@ -29,6 +29,12 @@ export interface TaskHandle {
 export type SiblingFailurePolicy = 'continue' | 'cancel-siblings'
 
 export interface CreateTaskOptions {
+	/**
+	 * Revalidate host authority at actual admission, including after a capacity wait.
+	 * Queue retries may invoke this more than once; checks must tolerate repeated calls.
+	 */
+	readonly beforeStart?: () => Promise<void>
+
 	/**
 	 * Observe events from this one delegated run when the scheduler can expose
 	 * them.

package/src/types/agent/task.ts

@@ -122,6 +122,7 @@ export interface AgentTask {
 	agentId: string
 	agent: Agent<BaseAgentConfig, BaseAgentResult>
 	childAbortController: AbortController
+	/** While pending admission this is the submitting authority; admitted tasks receive child scope. */
 	context: AgentTaskContext
 	state: AgentTaskState
 	result?: BaseAgentResult
@@ -142,6 +143,12 @@ export interface AgentTask {
  * WorkspaceRef triple atomically on every spawn.
  */
 export interface SendMessageOptions {
+	/**
+	 * Revalidate host authority before admission, including after a capacity wait.
+	 * Queue retries may invoke this more than once; checks must tolerate repeated calls.
+	 */
+	readonly beforeStart?: () => Promise<void>
+
 	/** See {@link import('./scheduler.js').CreateTaskOptions.toolScope}. Deny-only. */
 	readonly toolScope?: { readonly deny: readonly string[] }
 	/** See {@link import('./scheduler.js').CreateTaskOptions.personaOverride}. */
@@ -179,6 +186,12 @@ export interface SendMessageOptions {
 }
 
 export interface AgentManagerConfig {
+	/** Reject a full parent immediately (default), or retain bounded pending task handles. */
+	capacityBehavior?: 'reject' | 'queue'
+
+	/** Maximum tasks awaiting admission across this manager. Defaults to 128. */
+	maxPendingTasks?: number
+
 	maxDepth: number
 
 	evictionMs: number

package/src/types/computer-use/index.ts

@@ -30,6 +30,12 @@ export interface ComputerUseCapabilities {
 	readonly keyboard: boolean
 	readonly cursorPosition: boolean
 	readonly clipboard: boolean
+	/** Exact action subset when known. Refines the broad flags; absent retains their legacy interpretation. */
+	readonly supportedActions?: readonly ComputerUseAction['type'][]
+	/** Supported click buttons; absent leaves button admission to the host. */
+	readonly mouseClickButtons?: readonly MouseButton[]
+	/** Supported drag buttons; absent leaves button admission to the host. */
+	readonly mouseDragButtons?: readonly MouseButton[]
 	/**
 	 * Why every flag above is false, when a host loaded but the desktop did
 	 * not answer — a WSL process with PowerShell and no interactive Windows

package/src/types/errors/catalog.ts

@@ -157,7 +157,7 @@ export const DEFAULT_ERROR_RULES: readonly ErrorCatalogRule[] = [
 		id: 'provider.rate_limit',
 		when: (facts) => facts.code === 'rate_limit' || facts.status === 429,
 		message: 'The provider is rate limiting this run.',
-		hint: 'Automatic retries with backoff have already been exhausted. Lower concurrency, or wait for the quota window to reset before resuming.',
+		hint: 'Respect the provider retry delay when reported. Lower concurrency, or wait for the quota window to reset before resuming.',
 	},
 	{
 		id: 'provider.context_overflow',

package/src/types/hitl/index.ts

@@ -2,7 +2,7 @@ import type { WorkingStateSnapshot } from '../../compaction/wire.js'
 import type { SerializedSpanContext } from '../../telemetry/attributes.js'
 import type { CostInfo, TokenUsage } from '../common/index.js'
 import type { CheckpointId, PlanId, RunId } from '../ids/index.js'
-import type { Message } from '../message/index.js'
+import type { Message, UserMessage } from '../message/index.js'
 import type { PlanStatus } from '../plan/index.js'
 import type { TokenBudgetBinding } from '../run/token-budget-store.js'
 
@@ -212,6 +212,16 @@ export interface IterationCheckpoint {
 	runId: RunId
 	iteration: number
 	messages: Message[]
+	/**
+	 * Current operator/goal/steering text and provenance, independent of
+	 * compacted history. Attachments are not duplicated here. Older
+	 * checkpoints omit this field and use surviving history on resume.
+	 */
+	latestUserMessage?: UserMessage
+	/** Structured host-review rejections consumed at this checkpoint, independent of compacted messages. */
+	structuredReviewAttempts?: number
+	/** Native structured-output corrections consumed independently of message history. */
+	nativeStructuredAttempts?: number
 	tokenUsage: TokenUsage
 	costInfo: CostInfo
 	/**

package/src/types/memory/index.ts

@@ -31,11 +31,19 @@ export interface MemoryContent {
 	readonly metadata?: Record<string, unknown>
 }
 
+/** Metadata and body observed together at one store read boundary. */
+export interface MemoryRecord {
+	readonly entry: MemoryIndexEntry
+	readonly content: MemoryContent
+}
+
 export interface MemorySearchParams {
 	readonly query?: string
 	readonly tags?: string[]
 	readonly status?: MemoryStatus
 	readonly limit?: number
+	/** Match at least one exact normalized word token before limiting results. Empty means no constraint. */
+	readonly requiredIdentifiers?: readonly string[]
 }
 
 export interface MemorySearchResult {
@@ -52,10 +60,17 @@ export interface CreateMemoryParams {
 	readonly metadata?: Record<string, unknown>
 }
 
+/** Change a memory's content or explicitly archive/reactivate it. */
+export interface UpdateMemoryParams extends Partial<CreateMemoryParams> {
+	readonly status?: MemoryStatus
+}
+
 export interface MemoryStore {
 	create(params: CreateMemoryParams): Promise<{ entry: MemoryIndexEntry; content: MemoryContent }>
 	get(id: MemoryId): Promise<MemoryContent | undefined>
-	update(id: MemoryId, updates: Partial<CreateMemoryParams>): Promise<MemoryIndexEntry | undefined>
+	/** Current metadata/body snapshot; supports rechecking status after search. */
+	getRecord?(id: MemoryId): Promise<MemoryRecord | undefined>
+	update(id: MemoryId, updates: UpdateMemoryParams): Promise<MemoryIndexEntry | undefined>
 	delete(id: MemoryId): Promise<boolean>
 	list(params?: MemorySearchParams): Promise<MemorySearchResult>
 }

package/src/types/project/entity.ts

@@ -18,6 +18,7 @@ import type { ProjectId } from '../session/ids.js'
  */
 export interface ProjectConfig {
 	maxDelegationDepth: number
+	/** Maximum pending or active direct delegations; completed history does not consume capacity. */
 	maxDelegationWidth: number
 	maxInterventionDepth: number
 	sharedMemoryStores?: readonly MemoryStoreRef[]

package/src/types/provider/config.ts

@@ -121,6 +121,8 @@ export interface MockProviderConfig extends MockScript {
  * degradation is loud instead of silent.
  */
 export interface ProviderCapabilities {
+	/** Native JSON Schema response-format mapping. Absent means unsupported. */
+	supportsNativeStructuredOutput?: boolean
 	supportsTools: boolean
 	supportsStreaming: boolean
 	supportsFunctionCalling: boolean

package/src/types/provider/model.ts

@@ -14,6 +14,10 @@ export interface ModelInfo {
 	 * the answer; it must not be read as text-only.
 	 */
 	inputModalities?: readonly ModelInputModality[]
+	/** Exact selectable effort levels for this model and route. Absent means unknown; [] means unsupported. */
+	reasoningEffortLevels?: readonly import('./chat.js').ReasoningEffort[]
+	/** Published default, when established; must belong to reasoningEffortLevels when both are present. */
+	reasoningEffortDefault?: import('./chat.js').ReasoningEffort
 	/**
 	 * Tokens the model's context holds, when the driver knows.
 	 *

package/src/types/run/answer-review.ts

@@ -29,6 +29,8 @@ export type AnswerReview =
 export interface AnswerReviewContext {
 	readonly runId: RunId
 	readonly iteration: number
+	/** Run cancellation; reviewers should forward it to verification operations. */
+	readonly signal?: AbortSignal
 	/** The full history, so a reviewer can see how the answer was reached. */
 	readonly messages: readonly Message[]
 }

package/src/types/run/events.ts

@@ -101,6 +101,16 @@ interface RunEventEnvelope {
 }
 
 type CoreRunEvent =
+	| {
+			type: 'tool_calls_admitted'
+			runId: RunId
+			kind: 'initialize' | 'batch' | 'nested' | 'retry'
+			/** Newly reserved attempts; zero only for ledger initialization. */
+			count: number
+			/** Cumulative reserved attempts, including abandoned reservations. */
+			used: number
+			limit: number
+	  }
 	| { type: 'run_started'; runId: RunId; systemPrompt?: string }
 	| { type: 'iteration_started'; runId: RunId; iteration: number }
 	/**

package/src/types/run/prepare-step.ts

@@ -1,5 +1,5 @@
 import type { RunId } from '../ids/index.js'
-import type { Message } from '../message/index.js'
+import type { Message, UserMessage } from '../message/index.js'
 import type { ToolChoice } from '../provider/chat.js'
 import type { Skill } from '../skills/index.js'
 import type { StepResult } from './step.js'
@@ -21,6 +21,24 @@ export interface PrepareStepContext {
 	readonly stepNumber: number
 	/** Full history as it stands, so a decision can read what happened. */
 	readonly messages: readonly Message[]
+	/**
+	 * Latest operator, goal-round, or steering input accepted by this run,
+	 * retained even when compaction removes it from `messages`. Project
+	 * instructions and task-completion context do not replace operator intent.
+	 */
+	readonly latestUserMessage?: UserMessage
+	/** The run's cancellation signal, for bounded asynchronous preparation. */
+	readonly signal?: AbortSignal
+	/**
+	 * Estimated room for additional step context after existing messages,
+	 * earlier stages' system/skills, and a response reserve. Recomputed for
+	 * each stage and its selected model; not a billing limit or fit guarantee.
+	 * `beforeStep` observes its existing boundary before compaction runs.
+	 */
+	readonly contextBudget?: {
+		readonly remainingTokens: number
+		readonly windowTokens: number
+	}
 	/** Every completed step, in order. */
 	readonly steps: readonly StepResult[]
 

package/src/types/sandbox/index.ts

@@ -181,6 +181,20 @@ export interface SandboxFileEntry {
 	readonly size: number
 }
 
+/** A bounded search; patterns and depth are relative to the requested root. */
+export interface SandboxWalkFilesOptions {
+	readonly pattern?: string
+	readonly signal?: AbortSignal
+	/** Direct children have depth 1. Omitted means no additional depth bound. */
+	readonly maxDepth?: number
+	/** Positive safe integer bounding emitted matching files. */
+	readonly maxEntries: number
+	/** Positive safe integer bounding examined directory entries; defaults to 20,000. */
+	readonly maxVisitedEntries?: number
+	/** Match hidden names through wildcards; explicit dotfile patterns always work. Defaults to false. */
+	readonly includeHidden?: boolean
+}
+
 // ---------------------------------------------------------------------------
 // Sandbox interface — the core abstraction
 // ---------------------------------------------------------------------------
@@ -294,6 +308,13 @@ export interface Sandbox {
 	 * MAY throw for other I/O failures.
 	 */
 	listFiles(rootPath: string): Promise<readonly SandboxFileEntry[]>
+	/**
+	 * Lazily enumerate regular files as absolute paths, without following symlinks.
+	 * Cancellation and iterator return stop traversal. Exceeding the examined-entry
+	 * budget throws an error with code `ERR_FILE_WALK_LIMIT`; it is not an empty or
+	 * complete listing. Hosts requiring bounded search must refuse an absent method.
+	 */
+	walkFiles?(rootPath: string, options: SandboxWalkFilesOptions): AsyncIterable<SandboxFileEntry>
 	/**
 	 * Release every resource owned by this sandbox.
 	 *

package/src/types/structured-output/index.ts

@@ -1,10 +1,10 @@
 import type { z } from 'zod'
 
 /**
- * Configuration for structured output via tool constraint.
+ * Configuration for validated output via tool constraint or native JSON Schema.
  *
  * This configuration allows an agent to produce validated, typed output by
- * presenting the output schema as a special tool that the model must call.
+ * presenting the output schema as a tool by default, or as a native response format.
  */
 export interface StructuredOutputConfig<TSchema extends z.ZodType = z.ZodType> {
 	/**
@@ -13,6 +13,9 @@ export interface StructuredOutputConfig<TSchema extends z.ZodType = z.ZodType> {
 	 */
 	schema: TSchema
 
+	/** Default tool constraint, or native JSON schema on an explicitly capable driver. */
+	mode?: 'tool' | 'native'
+
 	/**
 	 * Turns spent re-prompting when the model answers in prose or fails
 	 * validation. Defaults to {@link DEFAULT_STRUCTURED_OUTPUT_RETRIES}.
@@ -21,6 +24,16 @@ export interface StructuredOutputConfig<TSchema extends z.ZodType = z.ZodType> {
 	 * than iterating against `maxIterations`.
 	 */
 	maxRetries?: number
+
+	/** Review the JSON-decoded result before settlement. Narrow the value before use: serialization may change schema output types. Exceptions fail the run; cancellation is propagated. */
+	review?: (
+		output: unknown,
+		context: import('../run/answer-review.js').AnswerReviewContext,
+	) =>
+		| import('../run/answer-review.js').AnswerReview
+		| Promise<import('../run/answer-review.js').AnswerReview>
+	/** Corrections allowed after host rejection, separate from schema retries. Default 3; zero allows no correction. */
+	maxReviews?: number
 }
 
 /**

package/src/types/tool/index.ts

@@ -14,6 +14,8 @@ import type { ToolPresentation } from './presentation.js'
 
 export interface ToolRegistryRef {
 	searchDeferred(query: string): ToolDefinition[]
+	/** Ranked active matches, when this registry supports active-tool discovery. */
+	searchActive?(query: string): ToolDefinition[]
 	activate(names: string[]): void
 	getAvailability(name: string): ToolAvailability
 }
@@ -633,6 +635,18 @@ export interface ToolDefinition<TInput = unknown> extends ToolPresentation<TInpu
 	isDestructive?(input: TInput): boolean
 	isConcurrencySafe?(input: TInput): boolean
 
+	/**
+	 * Opt-in ordering boundary in a direct model tool-call batch. Earlier
+	 * calls settle before this call starts; later calls wait for this call
+	 * to settle (including failed results). Defaults to false. Independent
+	 * calls between barriers retain their existing concurrency-safe behavior.
+	 * Nested dispatch is owned by its enclosing call, not separately queued;
+	 * mark the enclosing tool as a barrier to isolate its nested operations.
+	 * Deadlines still abandon uncooperative tools: settlement does not prove
+	 * their external effects have stopped, and does not imply success.
+	 */
+	executionBarrier?: boolean
+
 	/**
 	 * Where this tool came from, when it did not come from here.
 	 *
@@ -763,6 +777,8 @@ export interface ToolRegistryContract {
 	suspendAll(): void
 	hasSuspended(): boolean
 	searchDeferred(query: string): ToolDefinition[]
+	/** Ranked active matches, when this registry supports active-tool discovery. */
+	searchActive?(query: string): ToolDefinition[]
 	getCallableTools(toolNames?: string[]): ToolDefinition[]
 
 	/**