@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/domains/prompts/fragments/operating/delegation.md

@@ -1,42 +1,40 @@
 ---
 id: operating.delegation
 version: 1
-budgetTokens: 620
 description: Coordinator delegation and receipt discipline; rendered only when dispatch is on the surface
 ---
 
 # Delegation
 
-You coordinate a fleet of Clio agents through the dispatch tool. You
-plan, route, and synthesize work across turns.
-Explicit broad repository or codebase exploration is bounded
-agent automation: hand it to a worker with a concrete reconnaissance
-handoff before repo-wide reads, pinning `scout` when the Fleet roster
-lists it. Use dispatch for other bounded fleet work with a clear
-handoff. A sealed run
-receipt is the durable record for delegated work. Receipt integrity verifies
-that record; evidence verification separately describes validation. The
-worker's prose remains an advisory claim unless its evidence is verified or
-the parent spot-checks it.
-A successful reconnaissance receipt is an index. Spot-check a small,
-risk-weighted subset of its citations, normally no more than six parent
-read/search calls, then proceed or delegate a narrower verification task.
-Spot-check delegated claims before repeating them: re-read any cited
-file:line location, and re-run or inspect the named validation before
-repeating a "tests pass" claim.
-Parent spot-checking is not independent specialist confirmation. Use the
-dispatch briefing field for receipt-derived context/data; keep it separate
-from task instructions. Collect detached runs before final synthesis.
-The operator can also run workers themselves with /run and /delegate,
-outside your dispatch history, and hand a finished answer to you with
---share or /share. Such an answer arrives as operator text headed
-`[worker result] <agent> · run <id> · <outcome> · shared by the operator`,
-and its run id names a sealed receipt you can read. Treat that note as
-operator steering to use, like any operator text; it is not a tool result
-to check against your own dispatch history, and never dispatching that
-run is not a reason to dismiss it. Its prose is an advisory claim under
-the same spot-check discipline as any receipt.
-Report receipt integrity, evidence verification, briefing provenance, and
-project-context provenance separately. Failed, cap-exhausted, zero-tool,
-and citation-free reconnaissance is non-evidence: treat it as unconfirmed
-leads, never as validation.
+You coordinate Clio workers through the dispatch tool. Before your first
+edit, count the independent file-scoped changes the request asks for.
+Two or more, or any repository-wide exploration: dispatch, and do not
+edit those files yourself. One narrow change: do it yourself.
+For two or more changes, one dispatch call carries them all as `tasks`,
+one task per change, each naming its file in `intent`, with `agent`
+"coder" and `mode` "parallel". For exploration, dispatch `scout` with
+the question before any repo-wide grep or read, however small the
+repository looks. You keep synthesis and validation: when the receipts
+arrive, spot-check them and run the checks yourself. A worker whose
+intent declares `write_roots` is confined to them and has no bash or
+verify tool, so do not ask it to run tests or scripts: name the checks
+in `verification` and the host runs them after it finishes.
+A sealed run receipt is the durable record of delegated work; the
+worker's prose is an advisory claim until its evidence is verified or
+you spot-check it. Spot-check a small, risk-weighted subset of a
+reconnaissance receipt's citations (normally at most six read or search
+calls), and re-read any cited file:line and re-run or inspect the named
+validation before repeating a "tests pass" claim. Failed, cap-exhausted,
+zero-tool, or citation-free reconnaissance is unconfirmed leads, never
+validation.
+Put receipt-derived context in the dispatch briefing field, separate
+from task instructions. Collect detached runs before final synthesis,
+and report receipt integrity, evidence verification, briefing
+provenance, and project-context provenance as separate facts. Never
+narrate or summarize a worker you did not dispatch; if you cannot
+dispatch, say so and name the reason.
+A note headed `[worker result] <agent> · run <id> · <outcome> · shared
+by the operator` is operator text: a worker the operator ran with /run
+or /delegate and shared with --share or /share. Use it like any operator
+steering, read its receipt by run id, and apply the same spot-check
+discipline; not having dispatched it is no reason to dismiss it.

package/src/domains/prompts/fragments/operating/skills.md

@@ -1,33 +1,19 @@
 ---
 id: operating.skills
 version: 1
-budgetTokens: 340
 description: Coordinator skill suggestion discipline; rendered only when context is on the surface
 ---
 
 # Skills
 
-Skills package proven workflows. Some are installed; the rest sit in a
-marketplace the operator installs from, and context (scope="skills") is
-the one authoritative listing of both — never guess the inventory or
-search the repository for a skill file. The catalog spans git delivery
-(filing, fixing, and shipping issues), planning (intent, PRD, backlog,
-architecture, sprint slicing), coding practice (TDD, standards,
-prototyping), context priming and handoff, research workflows, and
-plan-stress-testing debates. When a task lands in one of those shapes,
-call context (scope="skills") first and match it against the catalog.
-Suggest the best match to the operator as /skill <name> — the sequence
-in order when skills compose — and let the operator decide before
-grinding through that workflow bare; a marketplace match is suggested
-the same way, and /skill <name> offers the install. When the operator
-names a skill or asks how one works, answer from that same listing.
-When a [Marketplace] reminder names an uninstalled skill for the
-current request, first check the installed side with context
-(scope="skills"); only if nothing installed serves and the named skill
-truly fits, put the install question to the operator with ask_user
-using exactly the four options the reminder states, then continue the
-task in the same turn. The harness performs any consented install;
-never install a skill yourself, and never offer one no reminder named.
-Only an explicit operator request activates a skill; never load one on
-your own. If nothing fits or the task is routine, proceed normally and
+Skills are operator-activated workflows: git delivery, planning, coding
+practice, context priming and handoff, research, and plan stress-testing.
+context (scope="skills") is the one authoritative listing of installed
+and marketplace skills; never guess the inventory or search the
+repository for one. When a task has one of those shapes, list them,
+suggest the best match as /skill <name> (the sequence in order when
+several compose), and continue the task without it: only the operator
+activates or installs a skill, and a [Marketplace] reminder states its
+own offer options. When the operator names a skill or asks how one
+works, answer from that listing. If nothing fits, proceed normally and
 suggest nothing.

package/src/domains/prompts/fragments/operating/worker.md

@@ -1,16 +1,9 @@
 ---
 id: operating.worker
 version: 1
-budgetTokens: 120
 description: Assigned-task contract for a bounded fleet worker
 ---
 
 # Assigned Task Contract
 
-The assigned task is authoritative. Role guidance is a persona, not a replacement task.
-
-Do not invent a different task, source tree, file path, or implementation plan.
-
-If the assigned task asks for an exact response, a direct answer, or no tool use, answer it directly without tool calls.
-
-Use tools only when necessary for the assigned task and admitted by the worker tool contract.
+The assigned task is authoritative; role guidance is a persona, not a replacement. Do not invent a different task, source tree, file path, or implementation plan.

package/src/domains/providers/contract.ts

@@ -59,6 +59,8 @@ export interface TargetStatus {
 	probeSurfaces?: Readonly<ProbeSurfaceMap>;
 	/** Ids returned by the last successful probeModels() call. */
 	discoveredModels: ReadonlyArray<string>;
+	/** Human-readable live/cache labels keyed by exact model slug. */
+	discoveredModelLabels?: Readonly<Record<string, string>>;
 	/**
 	 * Source for `discoveredModels`. `probe` means the target just returned a
 	 * live catalog, `cache` is a previously probed catalog preserved across a
@@ -93,7 +95,8 @@ export interface ProvidersContract {
 	 * `reasoning: false` skips an inference-based reasoning-capability probe while
 	 * retaining the target's liveness and model-catalog checks.
 	 */
-	probeTarget(id: string, options?: { reasoning?: boolean }): Promise<TargetStatus | null>;
+	/** Optional cancellation covers auth and metadata; a cancelled probe does not publish health. */
+	probeTarget(id: string, options?: { reasoning?: boolean; signal?: AbortSignal }): Promise<TargetStatus | null>;
 
 	/** Clear in-memory live connection state for a configured target. */
 	disconnectTarget(id: string): TargetStatus | null;

package/src/domains/providers/extension.ts

@@ -156,6 +156,7 @@ function sameProbeIdentity(previous: TargetDescriptor, next: TargetDescriptor):
 
 export interface ProbeMerge {
 	discoveredModels: string[];
+	discoveredModelLabels: Readonly<Record<string, string>>;
 	discoveredModelsSource: "probe" | "cache" | "runtime" | "none";
 	discoveredModelStates: NonNullable<TargetStatus["discoveredModelStates"]> | null;
 	probeCapabilities: NonNullable<TargetStatus["probeCapabilities"]> | null;
@@ -179,6 +180,7 @@ function mergeProbeResult(
 	probe: ProbeResult | null,
 	previous: TargetStatus | undefined,
 	cachedModels: ReadonlyArray<string> = [],
+	cachedModelLabels: Readonly<Record<string, string>> = {},
 ): ProbeMerge {
 	const probeSucceeded = probe?.ok ?? false;
 	const preservePrevious = !probeSucceeded && previous !== undefined && sameProbeIdentity(previous.target, target);
@@ -201,8 +203,14 @@ function mergeProbeResult(
 			[],
 	);
 	const discoveredModelStates = probe?.modelStates ?? (preservePrevious ? previous.discoveredModelStates : null) ?? null;
+	const discoveredModelLabels =
+		probe?.modelLabels ??
+		(preservePrevious ? previous.discoveredModelLabels : undefined) ??
+		(cachedModels.length > 0 ? cachedModelLabels : undefined) ??
+		{};
 	const merge: ProbeMerge = {
 		discoveredModels,
+		discoveredModelLabels,
 		discoveredModelsSource: discoveredModelsSource(probe, preservePrevious, previous, cachedModels, desc),
 		discoveredModelStates,
 		probeCapabilities,
@@ -225,14 +233,16 @@ function mergeProbeResult(
  * there is no live evidence either way.
  */
 function unservedDefaultModelReason(
-	desc: Pick<RuntimeDescriptor, "id">,
+	desc: Pick<RuntimeDescriptor, "id" | "externalAgentLoop">,
 	target: Pick<TargetDescriptor, "defaultModel">,
 	merge: Pick<ProbeMerge, "discoveredModels" | "discoveredModelsSource" | "discoveredModelStates">,
 ): string | null {
 	const model = target.defaultModel;
 	if (!model) return null;
 	if (merge.discoveredModelsSource !== "probe" || merge.discoveredModels.length === 0) return null;
-	if (listKnownModelsForRuntime(desc.id).length > 0) return null;
+	if (listKnownModelsForRuntime(desc.id).length > 0 && desc.externalAgentLoop?.modelCatalog !== "live-authoritative") {
+		return null;
+	}
 	if (merge.discoveredModels.includes(model)) return null;
 	// LM Studio lists a loaded model under its instance id and keeps the model
 	// key in the state map; the request path resolves either.
@@ -258,14 +268,22 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		return readSettings();
 	}
 
-	async function buildProbeContextForTarget(target: TargetDescriptor, desc: RuntimeDescriptor): Promise<ProbeContext> {
+	async function buildProbeContextForTarget(
+		target: TargetDescriptor,
+		desc: RuntimeDescriptor,
+		signal?: AbortSignal,
+	): Promise<ProbeContext> {
 		const probeCtx: ProbeContext = {
 			credentialsPresent: credentialsPresent(),
 			httpTimeoutMs: DEFAULT_PROBE_TIMEOUT_MS,
+			...(signal ? { signal } : {}),
 		};
 		if (!targetRequiresAuth(target, desc)) return probeCtx;
 		try {
-			const resolution = await authStore.resolveForTarget(resolveAuthTarget(target, desc), { includeFallback: false });
+			const resolution = await authStore.resolveForTarget(resolveAuthTarget(target, desc), {
+				includeFallback: false,
+				...(signal ? { signal } : {}),
+			});
 			if (resolution.apiKey) probeCtx.authToken = resolution.apiKey;
 		} catch {
 			// Authenticated probes should still return a runtime-specific missing-auth error.
@@ -325,8 +343,9 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			return out;
 		}
 		const availability = availabilityFor(desc, target, authStatusFor);
-		const cachedModels = readTargetModelSnapshot(target)?.models ?? [];
-		const merge = mergeProbeResult(desc, target, probe, previous, cachedModels);
+		const cachedSnapshot = readTargetModelSnapshot(target);
+		const cachedModels = cachedSnapshot?.models ?? [];
+		const merge = mergeProbeResult(desc, target, probe, previous, cachedModels, cachedSnapshot?.modelLabels ?? {});
 		const { capabilities, contextWindowProvenance } = capabilitiesFor(desc, target, merge, kb);
 		const healthy = probe !== null ? probe.ok : null;
 		const unservedDefault = probe?.ok ? unservedDefaultModelReason(desc, target, merge) : null;
@@ -353,6 +372,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			probeModelCapabilities: merge.probeModelCapabilities,
 			probeModelId: merge.probeModelId,
 			discoveredModels: merge.discoveredModels,
+			discoveredModelLabels: merge.discoveredModelLabels,
 			discoveredModelsSource: merge.discoveredModelsSource,
 			discoveredModelStates: merge.discoveredModelStates,
 		};
@@ -364,8 +384,9 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	async function probeTargetInternal(
 		target: TargetDescriptor,
 		live: boolean,
-		options?: { reasoning?: boolean },
+		options?: { reasoning?: boolean; signal?: AbortSignal },
 	): Promise<TargetStatus> {
+		options?.signal?.throwIfAborted();
 		const previous = statuses.get(target.id);
 		const desc = registry.get(target.runtime);
 		if (!desc) {
@@ -379,13 +400,15 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			statuses.set(target.id, status);
 			return status;
 		}
-		const probeCtx = await buildProbeContextForTarget(target, desc);
+		const probeCtx = await buildProbeContextForTarget(target, desc, options?.signal);
+		options?.signal?.throwIfAborted();
 		let probeResult: ProbeResult;
 		try {
 			probeResult = await desc.probe(target, probeCtx);
 		} catch (err) {
 			probeResult = { ok: false, error: err instanceof Error ? err.message : String(err) };
 		}
+		options?.signal?.throwIfAborted();
 		if (probeResult.ok && typeof desc.probeModels === "function" && !probeResult.models) {
 			try {
 				const ids = await desc.probeModels(target, probeCtx);
@@ -394,6 +417,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				// model discovery is best-effort; keep probe as-is.
 			}
 		}
+		options?.signal?.throwIfAborted();
 		if (probeResult.ok && options?.reasoning !== false && typeof desc.probeReasoning === "function") {
 			const settings = readConfig();
 			const orchestratorTarget = settings.chat.target === target.id ? settings.chat.model : null;
@@ -401,6 +425,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			if (candidateModelId) {
 				try {
 					const result = await desc.probeReasoning(target, candidateModelId, probeCtx);
+					options?.signal?.throwIfAborted();
 					reasoningCache.set(reasoningCacheKey(target.id, candidateModelId), result.reasoning);
 					const capabilityModelId = probeResult.capabilityModelId ?? null;
 					if (capabilityModelId === null || capabilityModelId === candidateModelId) {
@@ -422,10 +447,16 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				}
 			}
 		}
+		// A cancelled role preparation must not publish failed/stale target state.
+		options?.signal?.throwIfAborted();
 		const status = buildStatus(target, desc, probeResult, previous);
 		statuses.set(target.id, status);
 		if (probeResult.ok && probeResult.models !== undefined) {
-			recordTargetModelSnapshot(target, probeResult.models);
+			recordTargetModelSnapshot(
+				target,
+				probeResult.models,
+				probeResult.modelLabels ? { modelLabels: probeResult.modelLabels } : {},
+			);
 		}
 		// Durable so the next process resolves this endpoint's real slot count
 		// instead of the conservative default. Fire and forget: the probe's answer

package/src/domains/providers/index.ts

@@ -161,7 +161,7 @@ export {
 	VALID_THINKING_LEVELS,
 } from "./types/capability-flags.js";
 export { type ContextWindowSlots, formatContextWindowSlots } from "./types/context-window-slots.js";
-export { type CostProvenance, normalizeCostProvenance } from "./types/cost-provenance.js";
+export { type CostProvenance, normalizeCostProvenance, resolveCostProvenance } from "./types/cost-provenance.js";
 export type { KnowledgeBase, KnowledgeBaseEntry, KnowledgeBaseHit } from "./types/knowledge-base.js";
 export type {
 	ProbeContext,

package/src/domains/providers/model-capabilities.ts

@@ -14,6 +14,7 @@ export interface ModelCapabilityPatchTarget {
 	contextWindow?: number;
 	maxTokens?: number;
 	reasoning?: boolean;
+	clioCoder?: Record<string, unknown>;
 }
 
 /**
@@ -30,6 +31,14 @@ export function applyModelCapabilityPatch<T extends ModelCapabilityPatchTarget>(
 	if (typeof caps.contextWindow === "number") model.contextWindow = caps.contextWindow;
 	if (typeof caps.maxTokens === "number") model.maxTokens = caps.maxTokens;
 	if (typeof caps.reasoning === "boolean") model.reasoning = caps.reasoning;
+	// Refresh the probe-only control hint together with the capability snapshot.
+	// Missing metadata after a later probe must not retain an earlier route claim.
+	if (model.clioCoder || caps.thinkingControlRuntime !== undefined) {
+		const metadata = { ...model.clioCoder };
+		delete metadata.thinkingControlRuntime;
+		if (caps.thinkingControlRuntime !== undefined) metadata.thinkingControlRuntime = caps.thinkingControlRuntime;
+		model.clioCoder = metadata;
+	}
 	return model;
 }
 

package/src/domains/providers/model-discovery.ts

@@ -6,6 +6,7 @@ export type ProviderModelSource = "configured" | "live" | "catalog" | "default";
 
 export interface ProviderModelCandidate {
 	id: string;
+	label?: string;
 	source: ProviderModelSource;
 	loadState?: string;
 	loadStateDetail?: string;
@@ -100,6 +101,7 @@ export function modelCandidatesForStatus(status: TargetStatus): ProviderModelCan
 		const state = status.discoveredModelStates?.[trimmed];
 		out.push({
 			id: trimmed,
+			...(status.discoveredModelLabels?.[trimmed] ? { label: status.discoveredModelLabels[trimmed] } : {}),
 			source,
 			...(state ? { loadState: state.state } : {}),
 			...(state?.detail ? { loadStateDetail: state.detail } : {}),

package/src/domains/providers/model-runtime-capabilities.ts

@@ -36,7 +36,7 @@ export interface AppliedThinking {
 	mechanism: ThinkingMechanism;
 	effort?: string;
 	budgetTokens?: number;
-	chatTemplateKwargs?: Record<string, boolean>;
+	chatTemplateKwargs?: Record<string, boolean | string | number>;
 	noticeKind: AppliedThinkingNoticeKind;
 	notice: string;
 }
@@ -53,7 +53,20 @@ export interface ResolvedRequestCapability {
 	reasoningEffort?: string;
 	budgetTokens?: number;
 	budgetEnforcement: ThinkingBudgetEnforcement;
-	chatTemplateKwargs?: Record<string, boolean | string>;
+	chatTemplateKwargs?: Record<string, boolean | string | number>;
+	/**
+	 * Family-declared chat-template kwargs the runtime cannot carry. LM Studio
+	 * ignores `chat_template_kwargs` for every family measured, so the keys are
+	 * named here for the resolution diagnostics instead of riding in
+	 * `chatTemplateKwargs` only to be deleted at the wire.
+	 */
+	undeliverableChatTemplateKwargs?: UndeliverableChatTemplateKwargs;
+}
+
+export interface UndeliverableChatTemplateKwargs {
+	keys: string[];
+	/** True when the family entry itself marks the block `lmstudio: unsupported`. */
+	declaredUnsupported: boolean;
 }
 
 export interface ResolvedResponseCapability {
@@ -118,6 +131,7 @@ interface ClioRuntimeMetadata {
 		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		family?: string;
+		thinkingControlRuntime?: CapabilityFlags["thinkingControlRuntime"];
 		quirks?: LocalModelQuirks;
 	};
 	/** Released in-memory metadata name accepted at plugin/runtime read boundaries. */
@@ -127,6 +141,7 @@ interface ClioRuntimeMetadata {
 		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		family?: string;
+		thinkingControlRuntime?: CapabilityFlags["thinkingControlRuntime"];
 		quirks?: LocalModelQuirks;
 	};
 	compat?: {
@@ -335,14 +350,15 @@ function supportedEffortLevels(
 ): ReadonlyArray<ThinkingLevel> {
 	if (harmony) return HARMONY_LEVELS;
 	const efforts = quirks?.thinking?.effortByLevel;
-	if (!efforts) return baseLevels;
+	const byLevelValues = (quirks?.chatTemplateKwargs ?? quirks?.thinking?.chatTemplateKwargs)?.byLevel?.values;
+	if (!efforts && !byLevelValues) return baseLevels;
 	const out: ThinkingLevel[] = [];
 	if (baseLevels.includes("off")) out.push("off");
-	if (efforts.minimal !== undefined) out.push("minimal");
-	if (efforts.low !== undefined) out.push("low");
-	if (efforts.medium !== undefined) out.push("medium");
-	if (efforts.high !== undefined) out.push("high");
-	if (efforts.xhigh !== undefined) out.push("xhigh");
+	if (efforts?.minimal !== undefined || byLevelValues?.minimal !== undefined) out.push("minimal");
+	if (efforts?.low !== undefined || byLevelValues?.low !== undefined) out.push("low");
+	if (efforts?.medium !== undefined || byLevelValues?.medium !== undefined) out.push("medium");
+	if (efforts?.high !== undefined || byLevelValues?.high !== undefined) out.push("high");
+	if (efforts?.xhigh !== undefined || byLevelValues?.xhigh !== undefined) out.push("xhigh");
 	return out.length > 0 ? out : baseLevels;
 }
 
@@ -367,9 +383,10 @@ export function effectiveThinkingLevel(
 	const fallback = available[0] ?? "off";
 	if (!configured) return fallback;
 	if (available.includes(configured)) return configured;
-	// Catalog effort maps intentionally stop at xhigh; `max` must clamp to that
-	// supported ceiling instead of falling through to the generic low fallback.
-	if (configured === "max" && available.includes("xhigh")) return "xhigh";
+	// A family with xhigh but no high keeps the released high alias at its
+	// supported ceiling; neither high nor max may fall through to low.
+	if ((configured === "max" || (configured === "high" && !available.includes("high"))) && available.includes("xhigh"))
+		return "xhigh";
 	if ((configured === "high" || configured === "xhigh" || configured === "max") && available.includes("high")) {
 		return "high";
 	}
@@ -525,27 +542,71 @@ function resolveThinkingCapability(
 }
 
 /**
- * Runtimes whose OpenAI-compatible surface reads the on-off thinking control
- * from `reasoning_effort` rather than `chat_template_kwargs.enable_thinking`.
- * Measured against the live fleet on 2026-08-11 with
- * `nvidia-nemotron-3.5-lightning-30b-a3b`: LM Studio suppressed reasoning
- * entirely for `reasoning_effort: "none"` and ignored `enable_thinking: false`,
- * while llama.cpp did the reverse. Sending the wrong spelling reads as "no
- * preference" to the server, so the model keeps reasoning at every dial.
+ * Runtimes whose OpenAI-compatible surface ignores `chat_template_kwargs`
+ * and reads every thinking control from `reasoning_effort`. Measured against
+ * dynamo (LM Studio) on 2026-08-11 with `nvidia-nemotron-3.5-lightning-30b-a3b`
+ * and again on 2026-09-02 across three mechanisms: `enable_thinking: false`
+ * left 26 reasoning tokens on qwen3.8-27b (effort-levels), 52 on
+ * gemma-4-26b-a4b-it (on-off) and 105 on nemotron-3.5-lightning (on-off),
+ * while `reasoning_effort: "none"` produced 0 on each; llama.cpp does the
+ * reverse. Sending the wrong spelling reads as "no preference" to the
+ * server, so the model keeps reasoning at every dial. The same runtime drops
+ * a family's own kwargs (#267) for the same reason, so those are reported as
+ * undeliverable rather than merged into the request (#268).
  */
-const REASONING_EFFORT_ON_OFF_RUNTIMES: ReadonlySet<string> = new Set(["lmstudio"]);
+const REASONING_EFFORT_ONLY_RUNTIMES: ReadonlySet<string> = new Set(["lmstudio"]);
 
-/** `none` is LM Studio's documented off value; on-off models have no finer dial than `low`. */
+/** `none` is the observed LM Studio HTTP off value; on-off models have no finer dial than `low`. */
 function onOffReasoningEffort(thinkingActive: boolean): string {
 	return thinkingActive ? "low" : "none";
 }
 
+function resolveFamilyChatTemplateKwargs(
+	quirks: LocalModelQuirks | undefined,
+	effectiveLevel: ThinkingLevel,
+	configuredLevel: ThinkingLevel,
+): Record<string, boolean | string | number> | undefined {
+	const block = quirks?.chatTemplateKwargs ?? quirks?.thinking?.chatTemplateKwargs;
+	if (!block) return undefined;
+	const out: Record<string, boolean | string | number> = {};
+	if (block.static) {
+		for (const [k, v] of Object.entries(block.static)) {
+			out[k] = v;
+		}
+	}
+	if (block.byLevel) {
+		const byLevel = block.byLevel;
+		const val = byLevel.values[effectiveLevel] ?? byLevel.values[configuredLevel];
+		if (val !== undefined) {
+			out[byLevel.key] = val;
+		}
+	}
+	return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function familyKwargsDeclaredUnsupported(quirks: LocalModelQuirks | undefined, runtimeId: string): boolean {
+	if (runtimeId !== "lmstudio") return false;
+	const block = quirks?.chatTemplateKwargs ?? quirks?.thinking?.chatTemplateKwargs;
+	return block?.lmstudio === "unsupported" || block?.byLevel?.lmstudio === "unsupported";
+}
+
 function resolveRequestCapability(
 	thinking: ResolvedThinkingCapability,
 	parser: ResponseParserKind,
 	runtimeId: string,
+	quirks?: LocalModelQuirks,
 ): ResolvedRequestCapability {
 	const request: ResolvedRequestCapability = { budgetEnforcement: thinking.budgetEnforcement };
+	const effortOnly = REASONING_EFFORT_ONLY_RUNTIMES.has(runtimeId);
+	const familyKwargs = resolveFamilyChatTemplateKwargs(quirks, thinking.effectiveLevel, thinking.configuredLevel);
+	if (familyKwargs && effortOnly) {
+		request.undeliverableChatTemplateKwargs = {
+			keys: Object.keys(familyKwargs),
+			declaredUnsupported: familyKwargsDeclaredUnsupported(quirks, runtimeId),
+		};
+	} else if (familyKwargs) {
+		request.chatTemplateKwargs = { ...familyKwargs };
+	}
 	if (thinking.mechanism === "effort-levels" && thinking.effort) {
 		request.reasoningEffort = thinking.effort;
 	}
@@ -556,15 +617,21 @@ function resolveRequestCapability(
 		request.budgetTokens = thinking.budgetTokens;
 	}
 	if (thinking.mechanism === "on-off" && thinking.chatTemplateKwargs) {
-		request.chatTemplateKwargs = { ...thinking.chatTemplateKwargs };
-		if (REASONING_EFFORT_ON_OFF_RUNTIMES.has(runtimeId)) {
-			request.reasoningEffort = onOffReasoningEffort(thinking.thinkingActive);
-		}
+		request.chatTemplateKwargs = { ...(request.chatTemplateKwargs ?? {}), ...thinking.chatTemplateKwargs };
 	}
 	if (parser === "harmony" && thinking.effort) {
 		request.reasoningEffort = thinking.effort;
 		request.chatTemplateKwargs = { ...(request.chatTemplateKwargs ?? {}), reasoning_effort: thinking.effort };
 	}
+	// Every mechanism that means "off" has to reach an effort-only runtime as
+	// reasoning_effort "none": the template flag above is what llama.cpp reads
+	// and what LM Studio drops. An interactive session with thinking "off" had
+	// spent 37k reasoning tokens before the effort-levels case reached the
+	// wire, and on-off and budget-tokens families reasoned on the same way.
+	if (effortOnly && thinking.mechanism !== "none" && thinking.mechanism !== "always-on") {
+		if (!thinking.thinkingActive) request.reasoningEffort = onOffReasoningEffort(false);
+		else if (thinking.mechanism === "on-off") request.reasoningEffort = onOffReasoningEffort(true);
+	}
 	return request;
 }
 
@@ -583,7 +650,12 @@ export function resolveModelRuntimeCapabilities(
 		family,
 		capabilities: input.capabilities,
 		thinking,
-		request: resolveRequestCapability(thinking, parser, input.runtimeId),
+		request: resolveRequestCapability(
+			thinking,
+			parser,
+			input.runtimeId === "litellm" ? (input.capabilities.thinkingControlRuntime ?? input.runtimeId) : input.runtimeId,
+			quirks,
+		),
 		response: {
 			parser,
 			stripTokenizerSentinels: true,
@@ -671,6 +743,7 @@ function thinkingFormatFromModelApi(api: Api): CapabilityFlags["thinkingFormat"]
 
 function capabilitiesFromModel(model: Model<Api> & ClioRuntimeMetadata): CapabilityFlags {
 	const format = model.compat?.thinkingFormat ?? thinkingFormatFromModelApi(model.api);
+	const controlRuntime = (model.clioCoder ?? model.clio)?.thinkingControlRuntime;
 	const caps: CapabilityFlags = {
 		chat: true,
 		tools: true,
@@ -682,6 +755,7 @@ function capabilitiesFromModel(model: Model<Api> & ClioRuntimeMetadata): Capabil
 		fim: false,
 		contextWindow: model.contextWindow,
 		maxTokens: model.maxTokens,
+		...(controlRuntime ? { thinkingControlRuntime: controlRuntime } : {}),
 	};
 	if (
 		format === "qwen-chat-template" ||