@iowarp/clio-coder 0.3.1 → 0.3.3

package/src/engine/instrumented-tui.ts

@@ -0,0 +1,192 @@
+/**
+ * Render-transaction hooks around pi-tui's two concrete renderers.
+ *
+ * pi-tui deliberately exposes `doRender`, overlay composition, and line
+ * normalization as protected seams. Clio uses those seams instead of
+ * inferring frames from terminal writes: one `doRender()` is one frame, while
+ * any number of terminal writes (including the regular renderer's IME cursor
+ * write) can belong to that frame.
+ */
+
+import { type Terminal, TuiAltScreen, type TuiAltScreenOptions, TuiMainScreen } from "@earendil-works/pi-tui";
+
+export type TuiRenderPhase = "overlay" | "normalization" | "cursor";
+
+export interface TuiRenderObserver {
+	/** Optional fast-path used after a one-shot observer has delivered its frame. */
+	isEnabled?(): boolean;
+	beginFrame(fields: { mode: "regular" | "fullscreen"; columns: number; rows: number }): unknown;
+	endFrame(frame: unknown): void;
+	beginPhase(frame: unknown, phase: TuiRenderPhase): unknown;
+	endPhase(frame: unknown, phase: TuiRenderPhase, phaseToken: unknown): void;
+}
+
+export interface TuiRenderAdmission {
+	readonly blocked: boolean;
+	onWritable(listener: () => void): () => void;
+}
+
+class DeferredRenderAdmission {
+	private pending = false;
+	private force = false;
+	private release: (() => void) | null = null;
+
+	constructor(
+		private readonly admission: TuiRenderAdmission | undefined,
+		private readonly render: (force: boolean) => void,
+	) {}
+
+	request(force: boolean): boolean {
+		if (!this.admission?.blocked) return false;
+		this.pending = true;
+		this.force ||= force;
+		this.release ??= this.admission.onWritable(() => {
+			this.release?.();
+			this.release = null;
+			if (!this.pending) return;
+			const pendingForce = this.force;
+			this.pending = false;
+			this.force = false;
+			this.render(pendingForce);
+		});
+		return true;
+	}
+
+	/** A direct/final render supersedes any older request held behind the gate. */
+	settled(): void {
+		this.pending = false;
+		this.force = false;
+		this.release?.();
+		this.release = null;
+	}
+}
+
+export class InstrumentedTuiMainScreen extends TuiMainScreen {
+	constructor(
+		terminal: Terminal,
+		private readonly renderObserver: TuiRenderObserver,
+		showHardwareCursor?: boolean,
+		logDirectory?: string,
+		renderAdmission?: TuiRenderAdmission,
+	) {
+		super(terminal, showHardwareCursor, logDirectory);
+		this.deferredAdmission = new DeferredRenderAdmission(renderAdmission, (force) => super.requestRender(force));
+	}
+
+	override requestRender(force = false): void {
+		if (!this.deferredAdmission.request(force)) super.requestRender(force);
+	}
+
+	protected override doRender(): void {
+		this.deferredAdmission.settled();
+		if (this.renderObserver.isEnabled?.() === false) {
+			super.doRender();
+			return;
+		}
+		const frame = this.renderObserver.beginFrame({
+			mode: this.mode,
+			columns: this.terminal.columns,
+			rows: this.terminal.rows,
+		});
+		this.currentFrame = frame;
+		try {
+			super.doRender();
+		} finally {
+			this.currentFrame = undefined;
+			this.renderObserver.endFrame(frame);
+		}
+	}
+
+	protected override compositeOverlays(lines: string[], termWidth: number, termHeight: number): string[] {
+		return this.measure("overlay", () => super.compositeOverlays(lines, termWidth, termHeight));
+	}
+
+	protected override applyLineResets(lines: string[]): string[] {
+		return this.measure("normalization", () => super.applyLineResets(lines));
+	}
+
+	protected override extractCursorPosition(lines: string[], height: number): { row: number; col: number } | null {
+		return this.measure("cursor", () => super.extractCursorPosition(lines, height));
+	}
+
+	private measure<T>(phase: TuiRenderPhase, operation: () => T): T {
+		if (this.renderObserver.isEnabled?.() === false) return operation();
+		const frame = this.currentFrame;
+		if (frame === undefined) return operation();
+		const phaseToken = this.renderObserver.beginPhase(frame, phase);
+		try {
+			return operation();
+		} finally {
+			this.renderObserver.endPhase(frame, phase, phaseToken);
+		}
+	}
+
+	private currentFrame: unknown | undefined;
+	private readonly deferredAdmission: DeferredRenderAdmission;
+}
+
+export class InstrumentedTuiAltScreen extends TuiAltScreen {
+	private currentFrame: unknown | undefined;
+
+	constructor(
+		terminal: Terminal,
+		private readonly renderObserver: TuiRenderObserver,
+		showHardwareCursor?: boolean,
+		logDirectory?: string,
+		options?: TuiAltScreenOptions,
+		renderAdmission?: TuiRenderAdmission,
+	) {
+		super(terminal, showHardwareCursor, logDirectory, options);
+		this.deferredAdmission = new DeferredRenderAdmission(renderAdmission, (force) => super.requestRender(force));
+	}
+
+	override requestRender(force = false): void {
+		if (!this.deferredAdmission.request(force)) super.requestRender(force);
+	}
+
+	protected override doRender(): void {
+		this.deferredAdmission.settled();
+		if (this.renderObserver.isEnabled?.() === false) {
+			super.doRender();
+			return;
+		}
+		const frame = this.renderObserver.beginFrame({
+			mode: this.mode,
+			columns: this.terminal.columns,
+			rows: this.terminal.rows,
+		});
+		this.currentFrame = frame;
+		try {
+			super.doRender();
+		} finally {
+			this.currentFrame = undefined;
+			this.renderObserver.endFrame(frame);
+		}
+	}
+
+	protected override compositeOverlays(lines: string[], termWidth: number, termHeight: number): string[] {
+		return this.measure("overlay", () => super.compositeOverlays(lines, termWidth, termHeight));
+	}
+
+	protected override applyLineResets(lines: string[]): string[] {
+		return this.measure("normalization", () => super.applyLineResets(lines));
+	}
+
+	protected override extractCursorPosition(lines: string[], height: number): { row: number; col: number } | null {
+		return this.measure("cursor", () => super.extractCursorPosition(lines, height));
+	}
+
+	private measure<T>(phase: TuiRenderPhase, operation: () => T): T {
+		if (this.renderObserver.isEnabled?.() === false) return operation();
+		const frame = this.currentFrame;
+		if (frame === undefined) return operation();
+		const phaseToken = this.renderObserver.beginPhase(frame, phase);
+		try {
+			return operation();
+		} finally {
+			this.renderObserver.endPhase(frame, phase, phaseToken);
+		}
+	}
+
+	private readonly deferredAdmission: DeferredRenderAdmission;
+}

package/src/engine/messages.ts

@@ -0,0 +1,14 @@
+/**
+ * pi-agent-core owns the text that custom agent messages (bash executions,
+ * branch and compaction summaries) become when they are replayed to a model.
+ * Clio's replay builder maps its own session entries onto these so the
+ * wording never drifts from pi's `convertToLlm`.
+ */
+export {
+	type BashExecutionMessage,
+	BRANCH_SUMMARY_PREFIX,
+	BRANCH_SUMMARY_SUFFIX,
+	bashExecutionToText,
+	COMPACTION_SUMMARY_PREFIX,
+	COMPACTION_SUMMARY_SUFFIX,
+} from "@earendil-works/pi-agent-core";

package/src/engine/models.ts

@@ -0,0 +1,42 @@
+import { type Api, createModels, type KnownProvider, type Model } from "@earendil-works/pi-ai";
+import { amazonBedrockProvider } from "@earendil-works/pi-ai/providers/amazon-bedrock";
+import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
+import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
+import { googleProvider } from "@earendil-works/pi-ai/providers/google";
+import { groqProvider } from "@earendil-works/pi-ai/providers/groq";
+import { mistralProvider } from "@earendil-works/pi-ai/providers/mistral";
+import { openaiProvider } from "@earendil-works/pi-ai/providers/openai";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import { openrouterProvider } from "@earendil-works/pi-ai/providers/openrouter";
+
+/**
+ * Pi providers backing Clio's built-in runtime descriptors. Keep this list in
+ * lockstep with CATALOG_PROVIDER_BY_RUNTIME_ID; out-of-tree runtimes join the
+ * external compatibility universe before their modules evaluate.
+ */
+const CONFIGURED_PROVIDER_FACTORIES = [
+	amazonBedrockProvider,
+	anthropicProvider,
+	deepseekProvider,
+	googleProvider,
+	groqProvider,
+	mistralProvider,
+	openaiProvider,
+	openaiCodexProvider,
+	openrouterProvider,
+] as const;
+
+export const engineModels = createModels();
+for (const factory of CONFIGURED_PROVIDER_FACTORIES) engineModels.setProvider(factory());
+
+export function engineModelProviders(): KnownProvider[] {
+	return engineModels.getProviders().map((provider) => provider.id as KnownProvider);
+}
+
+export function engineModelsFor(provider: KnownProvider): Model<Api>[] {
+	return [...engineModels.getModels(provider)];
+}
+
+export function getEngineModel(provider: KnownProvider, modelId: string): Model<Api> | undefined {
+	return engineModels.getModel(provider, modelId);
+}

package/src/engine/oauth.ts

@@ -11,17 +11,20 @@
  */
 
 import type {
-	AuthInteraction,
 	OAuthAuth,
 	OAuthCredentials,
 	OAuthLoginCallbacks,
 	OAuthSelectPrompt,
+	ProviderAuthInteraction,
 } from "@earendil-works/pi-ai";
-import { findEnvKeys as piFindEnvKeys, getEnvApiKey as piGetEnvApiKey } from "@earendil-works/pi-ai/compat";
 import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
 import { githubCopilotProvider } from "@earendil-works/pi-ai/providers/github-copilot";
 import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
 import { alcfOAuthProvider } from "./alcf-oauth.js";
+import {
+	findEngineEnvKeys as findEngineEnvKeysRaw,
+	getEngineEnvApiKey as getEngineEnvApiKeyRaw,
+} from "./env-api-keys.js";
 
 export type { OAuthCredentials, OAuthLoginCallbacks, OAuthSelectPrompt };
 
@@ -35,13 +38,14 @@ export interface EngineOAuthProvider {
 	name: string;
 	usesCallbackServer: boolean;
 	login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
-	refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+	refreshToken(credentials: OAuthCredentials, signal: AbortSignal): Promise<OAuthCredentials>;
 	getApiKey(credentials: OAuthCredentials): Promise<string>;
 }
 
 /** Adapt Clio's legacy login callbacks to pi's AuthInteraction. */
-function interactionFromLoginCallbacks(callbacks: OAuthLoginCallbacks): AuthInteraction {
-	const interaction: AuthInteraction = {
+function interactionFromLoginCallbacks(callbacks: OAuthLoginCallbacks): ProviderAuthInteraction {
+	const interaction: ProviderAuthInteraction = {
+		signal: callbacks.signal ?? new AbortController().signal,
 		notify(event) {
 			switch (event.type) {
 				case "auth_url":
@@ -88,12 +92,11 @@ function interactionFromLoginCallbacks(callbacks: OAuthLoginCallbacks): AuthInte
 			}
 		},
 	};
-	if (callbacks.signal) interaction.signal = callbacks.signal;
 	return interaction;
 }
 
 function fromOAuthAuth(id: string, auth: OAuthAuth | undefined, usesCallbackServer: boolean): EngineOAuthProvider {
-	if (!auth) throw new Error(`pi-ai provider "${id}" no longer exposes an OAuth flow`);
+	if (!auth) throw new Error(`provider "${id}" does not expose an OAuth flow`);
 	return {
 		id,
 		name: auth.name,
@@ -101,8 +104,8 @@ function fromOAuthAuth(id: string, auth: OAuthAuth | undefined, usesCallbackServ
 		async login(callbacks) {
 			return auth.login(interactionFromLoginCallbacks(callbacks));
 		},
-		async refreshToken(credentials) {
-			return auth.refresh({ ...credentials, type: "oauth" });
+		async refreshToken(credentials, signal) {
+			return auth.refresh({ ...credentials, type: "oauth" }, signal);
 		},
 		async getApiKey(credentials) {
 			const resolved = await auth.toAuth({ ...credentials, type: "oauth" });
@@ -133,7 +136,7 @@ function registry(): Map<string, EngineOAuthProvider> {
 
 export function getEngineEnvApiKey(providerId: string): string | undefined {
 	try {
-		return piGetEnvApiKey(providerId);
+		return getEngineEnvApiKeyRaw(providerId);
 	} catch {
 		return undefined;
 	}
@@ -141,7 +144,7 @@ export function getEngineEnvApiKey(providerId: string): string | undefined {
 
 export function findEngineEnvKeys(providerId: string): string[] | undefined {
 	try {
-		return piFindEnvKeys(providerId);
+		return findEngineEnvKeysRaw(providerId);
 	} catch {
 		return undefined;
 	}
@@ -179,10 +182,11 @@ export async function loginWithEngineOAuthProvider(
 export async function refreshEngineOAuthCredentials(
 	providerId: string,
 	credentials: OAuthCredentials,
+	signal: AbortSignal,
 ): Promise<OAuthCredentials> {
 	const provider = registry().get(providerId);
 	if (!provider) throw new Error(`unknown OAuth provider: ${providerId}`);
-	return provider.refreshToken(credentials);
+	return provider.refreshToken(credentials, signal);
 }
 
 export async function getEngineOAuthApiKey(providerId: string, credentials: OAuthCredentials): Promise<string> {

package/src/engine/prompt-templates.ts

@@ -0,0 +1 @@
+export { parseCommandArgs, substituteArgs } from "@earendil-works/pi-agent-core";

package/src/engine/provider-payload.ts

@@ -1,10 +1,5 @@
 import { RESPONSE_SCHEMA_RUNTIME_ID } from "../core/response-schema.js";
 import type { ThinkingLevel } from "../domains/providers/index.js";
-import {
-	defaultAnthropicBudgetForLevel,
-	defaultAnthropicEffortForLevel,
-	type ThinkingEffortByLevel,
-} from "../domains/providers/thinking-control-policy.js";
 import type { EngineModel } from "./types.js";
 
 function reasoningSummaryForLevel(level: ThinkingLevel | undefined): "concise" | "detailed" | undefined {
@@ -17,6 +12,10 @@ function isOpenAIResponsesApi(api: string): boolean {
 	return api === "openai-codex-responses" || api === "openai-responses" || api === "azure-openai-responses";
 }
 
+function isAnthropicMessagesApi(api: string): boolean {
+	return api === "anthropic-messages";
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -45,10 +44,6 @@ function namedToolDefinitions(tools: unknown, toolName: string): unknown[] | nul
 	return narrowed.length > 0 ? narrowed : null;
 }
 
-function numberValue(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}
-
 function patchOpenAIReasoningSummaryPayload(
 	payload: unknown,
 	model: EngineModel,
@@ -69,65 +64,22 @@ function patchOpenAIReasoningSummaryPayload(
 	};
 }
 
-function isAnthropicMessagesApi(api: string): boolean {
-	return api === "anthropic-messages";
-}
-
-function anthropicThinkingLevelMap(model: EngineModel): ThinkingEffortByLevel | undefined {
-	return model.thinkingLevelMap as ThinkingEffortByLevel | undefined;
-}
-
-function anthropicUsesAdaptiveThinking(model: EngineModel): boolean {
-	const compat = model.compat as { forceAdaptiveThinking?: boolean } | undefined;
-	return compat?.forceAdaptiveThinking === true;
-}
-
-function patchAnthropicThinkingPayload(
-	payload: unknown,
-	model: EngineModel,
-	thinkingLevel: ThinkingLevel | undefined,
-): unknown | undefined {
-	if (!isAnthropicMessagesApi(model.api) || model.reasoning !== true) return undefined;
-	if (!thinkingLevel || thinkingLevel === "off" || !isRecord(payload)) return undefined;
-	const record = payload;
-	const existingThinking = isRecord(record.thinking) ? record.thinking : {};
-	const display = typeof existingThinking.display === "string" ? existingThinking.display : "summarized";
-
-	if (anthropicUsesAdaptiveThinking(model)) {
-		const effort = defaultAnthropicEffortForLevel(thinkingLevel, anthropicThinkingLevelMap(model));
-		const existingOutputConfig = isRecord(record.output_config) ? record.output_config : {};
-		return {
-			...record,
-			thinking: { ...existingThinking, type: "adaptive", display },
-			...(effort ? { output_config: { ...existingOutputConfig, effort } } : {}),
-		};
-	}
-
-	const maxTokens = numberValue(record.max_tokens) ?? model.maxTokens;
-	const budgetTokens = defaultAnthropicBudgetForLevel(thinkingLevel, maxTokens);
-	if (budgetTokens === undefined) return undefined;
-	return {
-		...record,
-		thinking: { ...existingThinking, type: "enabled", budget_tokens: budgetTokens, display },
-	};
-}
-
 /**
  * Align provider payloads with Clio's effective thinking level.
  *
  * OpenAI Responses defaults reasoning summaries to "auto", which can yield no
- * visible thinking blocks. Anthropic's generic stream path can also under-map
- * Clio levels when xhigh/adaptive metadata is available only on the model.
+ * visible thinking blocks, and the agent loop has no option for the summary
+ * field, so it is set here. Anthropic thinking is pi-owned: pi-ai's
+ * `streamSimple` maps the agent's thinking level onto adaptive effort (via
+ * `model.thinkingLevelMap` and `compat.forceAdaptiveThinking`) or a bounded
+ * `budget_tokens`, so the payload is left untouched for that API.
  */
 export function patchProviderThinkingPayload(
 	payload: unknown,
 	model: EngineModel,
 	thinkingLevel: ThinkingLevel | undefined,
 ): unknown | undefined {
-	return (
-		patchOpenAIReasoningSummaryPayload(payload, model, thinkingLevel) ??
-		patchAnthropicThinkingPayload(payload, model, thinkingLevel)
-	);
+	return patchOpenAIReasoningSummaryPayload(payload, model, thinkingLevel);
 }
 
 /**
@@ -234,7 +186,12 @@ export function patchToolChoiceNamedPayload(
 	if (model.api === "mistral-conversations") {
 		return { ...payload, tools, toolChoice: { type: "function", function: { name: toolName } } };
 	}
-	return { ...payload, tools, tool_choice: { type: "function", function: { name: toolName } } };
+	// Generic OpenAI-compatible servers reject the object form outright: both LM
+	// Studio and llama.cpp answer HTTP 400 with "Invalid tool_choice type:
+	// 'object'. Supported string values: none, auto, required". The tool surface
+	// is already narrowed to the single named definition above, so "required" is
+	// equivalent here and is the only spelling every server accepts.
+	return { ...payload, tools, tool_choice: "required" };
 }
 
 /** Attach llama-server's native JSON-schema response constraint without changing its tool surface. */

package/src/engine/strip-tokenizer-sentinels.ts

@@ -83,7 +83,7 @@ function isSentinelPrefix(tail: string): boolean {
  * at that point cannot be a sentinel and is emitted verbatim minus any
  * complete sentinels still embedded in it.
  */
-export interface SentinelStripper {
+interface SentinelStripper {
 	/** Sanitize the next streamed chunk, returning the safe-to-emit prefix. */
 	push(chunk: string): string;
 	/** Drain the trailing buffer at end-of-stream. */

package/src/engine/truncate.ts

@@ -0,0 +1,9 @@
+export {
+	formatSize,
+	GREP_MAX_LINE_LENGTH,
+	type TruncationOptions,
+	type TruncationResult,
+	truncateHead,
+	truncateLine,
+	truncateTail,
+} from "@earendil-works/pi-agent-core";

package/src/engine/tui.ts

@@ -9,24 +9,25 @@ export type {
 	AutocompleteProvider,
 	AutocompleteSuggestions,
 	Component,
-	EditorOptions,
 	EditorTheme,
-	ImageTheme,
 	Keybinding,
 	KeybindingConflict,
 	KeybindingDefinitions,
-	Keybindings,
 	KeybindingsConfig,
 	KeyId,
 	MarkdownTheme,
 	OverlayHandle,
 	OverlayOptions,
+	ScrollViewScrollbar,
 	SelectItem,
 	SelectListLayoutOptions,
 	SettingItem,
 	SettingsListTheme,
 	SlashCommand,
 	Terminal,
+	Tokens,
+	TUI,
+	TuiMode,
 } from "@earendil-works/pi-tui";
 
 /**
@@ -35,7 +36,7 @@ export type {
  * module; consumers accept this narrower shape so the helper is unit-testable
  * without a real ProcessTerminal.
  */
-export interface AgentProgressSink {
+interface AgentProgressSink {
 	setProgress(active: boolean): void;
 }
 
@@ -75,25 +76,32 @@ export {
 	Container,
 	Editor,
 	fuzzyFilter,
-	fuzzyMatch,
-	getCapabilities,
 	getKeybindings,
-	Image,
 	Input,
 	isKeyRelease,
 	KeybindingsManager,
-	Loader,
 	Markdown,
+	Marked,
 	matchesKey,
 	ProcessTerminal,
+	ScrollView,
 	setKeybindings,
+	stripTerminalSequences,
 	Text,
-	TUI,
 	TUI_KEYBINDINGS,
+	TuiAltScreen,
+	TuiMainScreen,
 	truncateToWidth,
+	VStack,
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+export {
+	InstrumentedTuiAltScreen,
+	InstrumentedTuiMainScreen,
+	type TuiRenderObserver,
+	type TuiRenderPhase,
+} from "./instrumented-tui.js";
 export type { SelectListTheme } from "./select-list.js";
 /**
  * SelectList ships from the engine as a thin subclass that honors a design

package/src/engine/types.ts

@@ -9,13 +9,10 @@
 export type {
 	AgentEvent,
 	AgentMessage,
-	AgentOptions,
-	AgentState,
 	AgentTool,
 	AgentToolResult,
-	StreamFn,
+	AgentToolUpdateCallback,
 } from "@earendil-works/pi-agent-core";
-export { Agent } from "@earendil-works/pi-agent-core";
 
 import type { AgentState as PiAgentState } from "@earendil-works/pi-agent-core";
 
@@ -36,6 +33,7 @@ export type MutableAgentState = Omit<PiAgentState, "errorMessage"> & {
 export type {
 	AnthropicMessagesCompat,
 	Api,
+	AuthOperationOptions,
 	ImageContent,
 	KnownProvider,
 	Model,
@@ -53,14 +51,13 @@ import type { Api as PiApi, Model as PiModel } from "@earendil-works/pi-ai";
  */
 export type EngineModel = PiModel<PiApi>;
 export type {
-	EditorOptions,
 	EditorTheme,
 	SelectItem,
 	SelectListLayoutOptions,
 	SettingItem,
 	SettingsListTheme,
+	TUI,
 } from "@earendil-works/pi-tui";
-export { TUI } from "@earendil-works/pi-tui";
 // SelectListTheme carries the Clio design cursor as an engine augmentation; see
 // ./select-list.ts. Re-export the augmented type so every engine surface agrees.
 export type { SelectListTheme } from "./select-list.js";

package/src/engine/worker-runtime-capabilities.ts

@@ -0,0 +1,5 @@
+/**
+ * Native worker registries expose no nested Clio dispatch contract. This is a
+ * compile-time runtime capability, not a setting.
+ */
+export const WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH = false;

package/src/engine/worker-runtime.ts

@@ -377,7 +377,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 	// pi-ai is process-local. The orchestrator registers Clio API providers in
 	// providers/extension.ts, but the worker subprocess starts a fresh process,
 	// so it must register them here before any agent.prompt() touches a local
-	// runtime (lmstudio-native, ollama-native).
+	// runtime (lmstudio, ollama-native).
 	registerClioApiProviders();
 	// The worker is a fresh process; mirror the orchestrator's global output
 	// budget so dispatched runs honor settings.defaults.maxTokens too. Use the

package/src/engine/worker-tools.ts

@@ -28,11 +28,13 @@ import {
 } from "../domains/safety/protected-artifacts.js";
 import { CONFIRMED_SCOPE, isSubset, READONLY_SCOPE, WORKSPACE_SCOPE } from "../domains/safety/scope.js";
 import { effectiveToolNames } from "../tools/agent-tools.js";
-import { registerAllTools } from "../tools/bootstrap.js";
+import { assertRegisteredBuiltinTools, registerCoreTools } from "../tools/core-bootstrap.js";
 import type { ToolProfileName } from "../tools/profiles.js";
 import { createRegistry, type RegistryDeps, type ToolRegistry } from "../tools/registry.js";
 import { type AgentLedgerPort, toolSignatureOf } from "../worker/protocol.js";
 
+export { WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH } from "./worker-runtime-capabilities.js";
+
 /**
  * Build a worker-local SafetyContract that owns its own loop-detector state.
  * The state is per-worker-run (one subprocess per run) so two concurrent
@@ -154,8 +156,12 @@ export function createWorkerToolRegistry(
 	// names a bare registry produces, so a conditional registration would drift
 	// the signature and fail admission; only the injected port varies, and a run
 	// without one answers that it has no coordination ledger.
-	registerAllTools(registry, {
+	const registration = registerCoreTools(registry, {
 		...(agentLedger ? { agentLedger } : {}),
+		// A worker cannot install a skill or reach the operator who could, so
+		// its skill listing carries installed (or bound) skills only; the
+		// marketplace is the orchestrator's to offer.
+		skillMarketplace: false,
 		getSkillLoaderOptions: () => ({
 			trustProjectCompatRoots: skillLoaderOptions?.trustProjectCompatRoots === true,
 			disableDiscovery: skillLoaderOptions?.noSkills === true,
@@ -164,6 +170,7 @@ export function createWorkerToolRegistry(
 				: {}),
 		}),
 	});
+	assertRegisteredBuiltinTools(registry, registration, false);
 	return registry;
 }
 
@@ -172,8 +179,6 @@ export function createWorkerToolRegistry(
  * mediates nested Clio dispatch. A constant, not a lookup: there is nothing to
  * vary by runtime, and a parameter would imply otherwise.
  */
-export const WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH = false;
-
 export interface AttestedToolIdentityInput {
 	allowedTools: ReadonlyArray<ToolName>;
 	/** False when the resolved runtime mediates no tool calls at all. */