pi-cohort 7.1.0 → 7.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [7.1.2] - 2026-09-29
+
+### Fixed
+
+- `typebox` moves from `dependencies` to an optional `peerDependencies: "*"` entry, which silences pi's "Host-provided extension packages must be declared in peerDependencies" startup warning and removes the second typebox copy from consumer installs. The detached async runner keeps working without its own copy: `spawnRunner` now passes pi's own `typebox`, `typebox/compile`, and `typebox/value` files to the bare jiti child through `JITI_ALIAS`, the same alias map pi's extension loader applies in-process, so the `Cannot find module 'typebox/compile'` crash from [#9](https://github.com/jjuraszek/pi-cohort/issues/9) stays fixed.
+
+## [7.1.1] - 2026-09-24
+
+### Changed
+
+- A dispatch that names no model now runs the child on the parent session's current model and thinking level instead of the child's saved `defaultModel`; `thinking: off` is emitted as `:off`, and `max` is a recognized level. Precedence: per-call `model:` > agent `model` / `thinking` (after `agentOverrides`) > parent session > none. Pin `subagents.agentOverrides.<agent>.model` to keep a child on a fixed model. Agents that pin `model` but not `thinking` now also take the parent's thinking level; set `thinking` to keep a fixed level. Children now bill on the parent's model, and an agent with `extensions:` whose parent model comes from an extension provider fails as an unknown model would; give it a pinned model or `fallbackModels`.
+
 ## [7.1.0] - 2026-09-20
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "7.1.0",
+  "version": "7.1.2",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",
@@ -64,7 +64,8 @@
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": ">=0.85.0",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-agent-core": {
@@ -78,16 +79,19 @@
     },
     "@earendil-works/pi-tui": {
       "optional": true
+    },
+    "typebox": {
+      "optional": true
     }
   },
   "dependencies": {
-    "jiti": "^2.7.0",
-    "typebox": "^1.3.11"
+    "jiti": "^2.7.0"
   },
   "devDependencies": {
     "@earendil-works/pi-agent-core": "^0.85.0",
     "@earendil-works/pi-ai": "^0.85.0",
     "@earendil-works/pi-coding-agent": "^0.85.0",
-    "@earendil-works/pi-tui": "^0.85.0"
+    "@earendil-works/pi-tui": "^0.85.0",
+    "typebox": "^1.3.11"
   }
 }

package/src/agents/agent-serializer.ts

@@ -42,7 +42,7 @@ export function serializeAgent(config: AgentConfig): string {
 	if (config.model) lines.push(`model: ${config.model}`);
 	const fallbackModelsValue = joinComma(config.fallbackModels);
 	if (fallbackModelsValue) lines.push(`fallbackModels: ${fallbackModelsValue}`);
-	if (config.thinking && config.thinking !== "off") lines.push(`thinking: ${config.thinking}`);
+	if (config.thinking) lines.push(`thinking: ${config.thinking}`);
 	lines.push(`systemPromptMode: ${config.systemPromptMode}`);
 	lines.push(`inheritProjectContext: ${config.inheritProjectContext ? "true" : "false"}`);
 	lines.push(`inheritSkills: ${config.inheritSkills ? "true" : "false"}`);

package/src/runs/background/async-execution.ts

@@ -14,7 +14,7 @@ import { injectSingleOutputInstruction, normalizeSingleOutputOverride, resolvePa
 import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveStepBehavior, suppressProgressForReadOnlyTask, writeInitialProgressFile, type ChainStep, type ResolvedStepBehavior, type SequentialStep, type StepOverrides } from "../../shared/settings.ts";
 import type { RunnerStep } from "../shared/parallel-utils.ts";
 import { resolvePiPackageRoot } from "../shared/pi-spawn.ts";
-import { ensureJitiCliPath } from "../shared/jiti-cli.ts";
+import { ensureJitiCliPath, resolveHostModuleAliases } from "../shared/jiti-cli.ts";
 export { createJitiCliResolver } from "../shared/jiti-cli.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.ts";
 import { resolveChildCwd } from "../../shared/utils.ts";
@@ -51,6 +51,10 @@ interface AsyncExecutionContext {
 	cwd: string;
 	currentSessionId: string;
 	currentModelProvider?: string;
+	/** Parent session model as provider/id, captured at dispatch */
+	parentModel?: string;
+	/** Parent session thinking level, captured at dispatch */
+	parentThinking?: string;
 	executionBackend?: string;
 }
 
@@ -141,7 +145,7 @@ export function isAsyncAvailable(): boolean {
  * Falls back to ignored stdio if the log file cannot be opened; the parent always
  * closes its copy of the fd, on every exit path.
  */
-export function spawnDetachedWithLog(command: string, args: string[], cwd: string, asyncDir: string, spawnImpl: typeof spawn = spawn): { pid?: number; error?: string } {
+export function spawnDetachedWithLog(command: string, args: string[], cwd: string, asyncDir: string, spawnImpl: typeof spawn = spawn, env?: NodeJS.ProcessEnv): { pid?: number; error?: string } {
 	let fd: number | undefined;
 	try {
 		try {
@@ -152,6 +156,7 @@ export function spawnDetachedWithLog(command: string, args: string[], cwd: strin
 		}
 		const proc = spawnImpl(command, args, {
 			cwd,
+			env,
 			detached: true,
 			stdio: fd === undefined ? "ignore" : ["ignore", fd, fd],
 			windowsHide: true,
@@ -183,7 +188,7 @@ export function spawnRunner(
 	suffix: string,
 	cwd: string,
 	asyncDir: string,
-	deps: { ensureJiti?: () => string | undefined; spawnImpl?: typeof spawn } = {},
+	deps: { ensureJiti?: () => string | undefined; spawnImpl?: typeof spawn; hostAliases?: () => Record<string, string> } = {},
 ): { pid?: number; error?: string } {
 	const ensureJiti = deps.ensureJiti ?? ensureJitiCliPath;
 	const jitiCliPath = ensureJiti();
@@ -205,7 +210,12 @@ export function spawnRunner(
 	fs.writeFileSync(cfgPath, JSON.stringify(cfg));
 	const runner = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.ts");
 
-	return spawnDetachedWithLog(process.execPath, [jitiCliPath, runner, cfgPath], cwd, asyncDir, deps.spawnImpl ?? spawn);
+	const aliases = (deps.hostAliases ?? resolveHostModuleAliases)();
+	const env = Object.keys(aliases).length > 0
+		? { ...process.env, JITI_ALIAS: JSON.stringify(aliases) }
+		: process.env;
+
+	return spawnDetachedWithLog(process.execPath, [jitiCliPath, runner, cfgPath], cwd, asyncDir, deps.spawnImpl ?? spawn, env);
 }
 
 /**
@@ -355,8 +365,10 @@ export function executeAsyncChain(
 		taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, runnerCwd);
 		const task = injectSingleOutputInstruction(`${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`, outputPath);
 
-		const primaryModel = resolveModelCandidate(behavior.model ?? a.model, availableModels, ctx.currentModelProvider);
-		const model = applyThinkingSuffix(primaryModel, a.thinking);
+		const primaryRaw = behavior.model ?? a.model ?? ctx.parentModel;
+		const thinking = a.thinking ?? ctx.parentThinking;
+		const primaryModel = resolveModelCandidate(primaryRaw, availableModels, ctx.currentModelProvider);
+		const model = applyThinkingSuffix(primaryModel, thinking);
 		return {
 			agent: s.agent,
 			task,
@@ -366,9 +378,9 @@ export function executeAsyncChain(
 			structured: Boolean(s.outputSchema),
 			cwd: stepCwd,
 			model,
-			thinking: resolveEffectiveThinking(model, a.thinking),
-			modelCandidates: buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
-				applyThinkingSuffix(candidate, a.thinking),
+			thinking: resolveEffectiveThinking(model, thinking),
+			modelCandidates: buildModelCandidates(primaryRaw, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
+				applyThinkingSuffix(candidate, thinking),
 			),
 			tools: a.tools,
 			extensions: a.extensions,
@@ -670,10 +682,9 @@ export function executeAsyncSingle(
 	const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
 	if (validationError) return formatAsyncStartError("single", validationError);
 	const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath);
-	const model = applyThinkingSuffix(
-		resolveModelCandidate(params.modelOverride ?? agentConfig.model, availableModels, ctx.currentModelProvider),
-		agentConfig.thinking,
-	);
+	const primaryRaw = params.modelOverride ?? agentConfig.model ?? ctx.parentModel;
+	const thinking = agentConfig.thinking ?? ctx.parentThinking;
+	const model = applyThinkingSuffix(resolveModelCandidate(primaryRaw, availableModels, ctx.currentModelProvider), thinking);
 	let spawnResult: { pid?: number; error?: string } = {};
 	try {
 		spawnResult = spawnRunner(
@@ -685,9 +696,9 @@ export function executeAsyncSingle(
 						task: taskWithOutputInstruction,
 						cwd: runnerCwd,
 						model,
-						thinking: resolveEffectiveThinking(model, agentConfig.thinking),
-						modelCandidates: buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
-							applyThinkingSuffix(candidate, agentConfig.thinking),
+						thinking: resolveEffectiveThinking(model, thinking),
+						modelCandidates: buildModelCandidates(primaryRaw, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
+							applyThinkingSuffix(candidate, thinking),
 						),
 						tools: agentConfig.tools,
 						extensions: agentConfig.extensions,

package/src/runs/foreground/chain-clarify.ts

@@ -11,7 +11,7 @@ import { matchesKey, visibleWidth, truncateToWidth } from "@earendil-works/pi-tu
 import type { AgentConfig } from "../../agents/agents.ts";
 import type { ResolvedStepBehavior } from "../../shared/settings.ts";
 import { resolveModelCandidate, splitThinkingSuffix } from "../shared/model-fallback.ts";
-import { findModelInfo, getSupportedThinkingLevels, type ModelInfo, type ThinkingLevel } from "../../shared/model-info.ts";
+import { findModelInfo, getSupportedThinkingLevels, splitKnownThinkingSuffix, type ModelInfo, type ThinkingLevel } from "../../shared/model-info.ts";
 
 type ClarifyMode = 'single' | 'parallel' | 'chain';
 
@@ -696,9 +696,8 @@ export class ChainClarifyComponent implements Component {
 		const currentModel = this.getEffectiveBehavior(stepIndex).model;
 		if (!currentModel) return;
 
-		const { baseModel } = splitThinkingSuffix(currentModel);
-		const newModel = level === "off" ? baseModel : `${baseModel}:${level}`;
-		this.updateBehavior(stepIndex, "model", newModel);
+		const { baseModel } = splitKnownThinkingSuffix(currentModel);
+		this.updateBehavior(stepIndex, "model", `${baseModel}:${level}`);
 	}
 
 	private filterSkills(): void {
@@ -1009,7 +1008,8 @@ export class ChainClarifyComponent implements Component {
 			"low": "Light reasoning",
 			"medium": "Moderate reasoning",
 			"high": "Deep reasoning",
-			"xhigh": "Maximum reasoning (ultrathink)",
+			"xhigh": "Extra-deep reasoning (ultrathink)",
+			"max": "Provider maximum reasoning",
 		};
 
 		const levels = this.getAvailableThinkingLevels(this.editingStep!);

package/src/runs/foreground/chain-execution.ts

@@ -8,7 +8,7 @@ import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { ChainClarifyComponent, type ChainClarifyResult, type BehaviorOverride } from "./chain-clarify.ts";
-import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { parentModelFullId, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import {
 	resolveChainTemplates,
 	createChainDir,
@@ -58,6 +58,7 @@ import {
 	resolveChildMaxSubagentDepth,
 } from "../../shared/types.ts";
 import { resolveModelCandidate } from "../shared/model-fallback.ts";
+import { applyThinkingSuffix } from "../shared/pi-args.ts";
 import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
 import { ChainOutputValidationError, outputEntryFromResult, resolveOutputReferences, validateChainOutputBindings } from "../shared/chain-outputs.ts";
@@ -278,6 +279,8 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				modelOverride: effectiveModel,
 				availableModels: input.availableModels,
 				preferredModelProvider: input.ctx.model?.provider,
+				parentModel: parentModelFullId(input.ctx.model),
+				parentThinking: input.ctx.thinkingLevel,
 				skills: behavior.skills === false ? [] : behavior.skills,
 				structuredOutput: structuredRuntime,
 				acceptance: task.acceptance,
@@ -512,6 +515,14 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			resolveStepBehavior(config, stepOverrides[i]!, chainSkills),
 		);
 		const flatTemplates = templates as string[];
+		// Seed what dispatch will resolve so the screen shows it and the thinking selector is enabled;
+		// untouched steps still reach runSync with no override and inherit there.
+		const parentModel = parentModelFullId(ctx.model);
+		const seededBehaviors = resolvedBehaviors.map((behavior, i) => {
+			const model = behavior.model ?? parentModel;
+			if (!model) return behavior;
+			return { ...behavior, model: applyThinkingSuffix(model, agentConfigs[i]!.thinking ?? ctx.thinkingLevel) };
+		});
 
 		const result = await ctx.ui.custom<ChainClarifyResult>(
 			(tui, theme, _kb, done) =>
@@ -522,7 +533,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					flatTemplates,
 					originalTask,
 					chainDir,
-					resolvedBehaviors,
+					seededBehaviors,
 					availableModels,
 					ctx.model?.provider,
 					availableSkills,
@@ -1030,6 +1041,8 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				modelOverride: effectiveModel,
 				availableModels,
 				preferredModelProvider: ctx.model?.provider,
+				parentModel: parentModelFullId(ctx.model),
+				parentThinking: ctx.thinkingLevel,
 				skills: behavior.skills === false ? [] : behavior.skills,
 				structuredOutput: structuredRuntime,
 				acceptance: seqStep.acceptance,

package/src/runs/foreground/execution.ts

@@ -684,11 +684,12 @@ export async function runSync(
 	}
 
 	const candidates = buildModelCandidates(
-		options.modelOverride ?? agent.model,
+		options.modelOverride ?? agent.model ?? options.parentModel,
 		agent.fallbackModels,
 		options.availableModels,
 		options.preferredModelProvider,
 	);
+	const effectiveAgent: AgentConfig = { ...agent, thinking: agent.thinking ?? options.parentThinking };
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [];
 	const aggregateUsage = emptyUsage();
@@ -751,7 +752,7 @@ export async function runSync(
 					owner: externalOwner,
 					attemptId: `${childId}-attempt-${i}`,
 					runtimeCwd,
-					agent,
+					agent: effectiveAgent,
 					model: candidate,
 					task: taskWithAcceptance,
 					options,
@@ -762,7 +763,7 @@ export async function runSync(
 			}
 		} else {
 			result = await (dependencies.runNativeAttempt ?? runSingleAttempt)(
-				runtimeCwd, agent, taskWithAcceptance, candidate, options, shared,
+				runtimeCwd, effectiveAgent, taskWithAcceptance, candidate, options, shared,
 			);
 		}
 		lastResult = result;

package/src/runs/foreground/subagent-executor.ts

@@ -6,7 +6,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { AgentConfig, AgentScope } from "../../agents/agents.ts";
 import { getArtifactsDir } from "../../shared/artifacts.ts";
 import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
-import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { parentModelFullId, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import { executeChain } from "./chain-execution.ts";
 import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
 import { handleManagementAction } from "../../agents/agent-management.ts";
@@ -210,6 +210,18 @@ function nestedResolutionScopeForExecutor(deps: ExecutorDeps): NestedRunResoluti
 	};
 }
 
+function buildAsyncContext(ctx: ExtensionContext, deps: ExecutorDeps, cwd: string) {
+	return {
+		pi: deps.pi,
+		cwd,
+		currentSessionId: deps.state.currentSessionId!,
+		currentModelProvider: ctx.model?.provider,
+		parentModel: parentModelFullId(ctx.model),
+		parentThinking: ctx.thinkingLevel,
+		executionBackend: deps.config.executionBackend,
+	};
+}
+
 function foregroundStatusResult(control: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never): AgentToolResult<Details> {
 	let nestedWarning: string | undefined;
 	try {
@@ -591,13 +603,7 @@ async function resumeAsyncRun(input: {
 		agent: target.agent,
 		task: buildRevivedAsyncTask(target, followUp),
 		agentConfig,
-		ctx: {
-			pi: input.deps.pi,
-			cwd: input.requestCwd,
-			currentSessionId: input.deps.state.currentSessionId,
-			currentModelProvider: input.ctx.model?.provider,
-			executionBackend: input.deps.config.executionBackend,
-		},
+		ctx: buildAsyncContext(input.ctx, input.deps, input.requestCwd),
 		cwd: effectiveCwd,
 		maxOutput: input.params.maxOutput,
 		artifactsDir: input.deps.tempArtifactsDir,
@@ -974,13 +980,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		};
 	}
 	const id = randomUUID();
-	const asyncCtx = {
-		pi: deps.pi,
-		cwd: ctx.cwd,
-		currentSessionId: deps.state.currentSessionId!,
-		currentModelProvider: ctx.model?.provider,
-		executionBackend: deps.config.executionBackend,
-	};
+	const asyncCtx = buildAsyncContext(ctx, deps, ctx.cwd);
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
 	const currentProvider = ctx.model?.provider;
@@ -1164,13 +1164,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 			};
 		}
 		const id = randomUUID();
-		const asyncCtx = {
-			pi: deps.pi,
-			cwd: ctx.cwd,
-			currentSessionId: deps.state.currentSessionId!,
-			currentModelProvider: ctx.model?.provider,
-			executionBackend: deps.config.executionBackend,
-		};
+		const asyncCtx = buildAsyncContext(ctx, deps, ctx.cwd);
 		const asyncChain = wrapChainTasksForFork(chainResult.requestedAsync.chain, params.context);
 		return executeAsyncChain(id, {
 			chain: asyncChain,
@@ -1432,6 +1426,8 @@ async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Pr
 			modelOverride: input.modelOverrides[index],
 			availableModels: input.availableModels,
 			preferredModelProvider: input.ctx.model?.provider,
+			parentModel: parentModelFullId(input.ctx.model),
+			parentThinking: input.ctx.thinkingLevel,
 			skills: effectiveSkills === false ? [] : effectiveSkills,
 			acceptance: task.acceptance,
 			acceptanceContext: { mode: "parallel" },
@@ -1605,13 +1601,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 				};
 			}
 			const id = randomUUID();
-			const asyncCtx = {
-				pi: deps.pi,
-				cwd: ctx.cwd,
-				currentSessionId: deps.state.currentSessionId!,
-				currentModelProvider: ctx.model?.provider,
-				executionBackend: deps.config.executionBackend,
-			};
+			const asyncCtx = buildAsyncContext(ctx, deps, ctx.cwd);
 			const parallelTasks = tasks.map((t, i) => {
 				const taskText = params.context === "fork" ? wrapForkTask(taskTexts[i]!) : taskTexts[i]!;
 				const progress = taskDisallowsFileUpdates(taskText) ? false : behaviorOverrides[i]?.progress;
@@ -1883,13 +1873,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 				};
 			}
 			const id = randomUUID();
-			const asyncCtx = {
-				pi: deps.pi,
-				cwd: ctx.cwd,
-				currentSessionId: deps.state.currentSessionId!,
-				currentModelProvider: ctx.model?.provider,
-				executionBackend: deps.config.executionBackend,
-			};
+			const asyncCtx = buildAsyncContext(ctx, deps, ctx.cwd);
 			return executeAsyncSingle(id, {
 				agent: params.agent!,
 				task: params.context === "fork" ? wrapForkTask(task) : task,
@@ -1993,6 +1977,8 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		modelOverride,
 		availableModels,
 		preferredModelProvider: currentProvider,
+		parentModel: parentModelFullId(ctx.model),
+		parentThinking: ctx.thinkingLevel,
 		skills: effectiveSkills,
 		acceptance: params.acceptance,
 		acceptanceContext: { mode: "single" },

package/src/runs/shared/jiti-cli.ts

@@ -24,17 +24,23 @@ function resolveJitiCliFromPackageJson(packageJsonPath: string): string | undefi
 	return undefined;
 }
 
-function resolveJitiCliPath(): string | undefined {
-	const candidates: Array<() => string | undefined> = [
-		() => require.resolve("jiti/package.json"),
+function hostResolveCandidates(specifier: string): Array<() => string | undefined> {
+	return [
+		() => require.resolve(specifier),
 		() => piPackageRoot
-			? createRequire(path.join(piPackageRoot, "package.json")).resolve("jiti/package.json")
+			? createRequire(path.join(piPackageRoot, "package.json")).resolve(specifier)
 			: undefined,
 		() => {
 			if (!process.argv[1]) return undefined;
 			const piEntry = fs.realpathSync(process.argv[1]);
-			return createRequire(piEntry).resolve("jiti/package.json");
+			return createRequire(piEntry).resolve(specifier);
 		},
+	];
+}
+
+function resolveJitiCliPath(): string | undefined {
+	const candidates = [
+		...hostResolveCandidates("jiti/package.json"),
 		() => piPackageRoot ? path.join(piPackageRoot, "node_modules", "jiti", "package.json") : undefined,
 	];
 	for (const candidate of candidates) {
@@ -50,6 +56,31 @@ function resolveJitiCliPath(): string | undefined {
 	return undefined;
 }
 
+function resolveFromHost(specifier: string): string | undefined {
+	for (const candidate of hostResolveCandidates(specifier)) {
+		try {
+			const resolved = candidate();
+			if (resolved) return resolved;
+		} catch {
+			// Candidate not available in this install, continue probing.
+		}
+	}
+	return undefined;
+}
+
+// Pi's extension loader aliases these to its own copies; the detached runner boots
+// under the bare jiti CLI, so it gets the same map through JITI_ALIAS.
+const HOST_ALIASED_SPECIFIERS = ["typebox", "typebox/compile", "typebox/value"];
+
+export function resolveHostModuleAliases(): Record<string, string> {
+	const aliases: Record<string, string> = {};
+	for (const specifier of HOST_ALIASED_SPECIFIERS) {
+		const resolved = resolveFromHost(specifier);
+		if (resolved) aliases[specifier] = resolved;
+	}
+	return aliases;
+}
+
 export function createJitiCliResolver(deps: { resolve?: () => string | undefined; exists?: (p: string) => boolean } = {}): () => string | undefined {
 	const resolve = deps.resolve ?? resolveJitiCliPath;
 	const exists = deps.exists ?? ((p: string) => fs.existsSync(p));

package/src/runs/shared/pi-args.ts

@@ -6,7 +6,7 @@ import { encodeNestedPathEnv, parseNestedPathEnv, type NestedPathEntry } from ".
 import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, STRUCTURED_OUTPUT_TOOL_NAME } from "./structured-output.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 const TASK_ARG_LIMIT = 8000;
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
 const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", "fanout-child.ts");
@@ -73,7 +73,7 @@ export function runDirEnv(asyncDir: string): Record<string, string> {
 }
 
 export function applyThinkingSuffix(model: string | undefined, thinking: string | undefined): string | undefined {
-	if (!model || !thinking || thinking === "off") return model;
+	if (!model || !thinking) return model;
 	const colonIdx = model.lastIndexOf(":");
 	if (colonIdx !== -1 && THINKING_LEVELS.includes(model.substring(colonIdx + 1))) return model;
 	return `${model}:${thinking}`;

package/src/shared/model-info.ts

@@ -1,4 +1,4 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export type ThinkingLevel = typeof THINKING_LEVELS[number];
 export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
 
@@ -63,16 +63,21 @@ export function findModelInfo(model: string | undefined, availableModels: ModelI
 }
 
 export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
-	if (!model) return [...THINKING_LEVELS];
+	if (!model) return THINKING_LEVELS.filter((level) => level !== "max");
 	if (model.reasoning === false) return ["off"];
 
-	if (!model.thinkingLevelMap) return [...THINKING_LEVELS];
+	if (!model.thinkingLevelMap) return THINKING_LEVELS.filter((level) => level !== "max");
 
 	const levels = THINKING_LEVELS.filter((level) => {
 		const mapped = model.thinkingLevelMap?.[level];
 		if (mapped === null) return false;
-		if (level === "xhigh") return mapped !== undefined;
+		if (level === "xhigh" || level === "max") return mapped !== undefined;
 		return true;
 	});
 	return levels;
 }
+
+/** Provider-qualified id of the parent session model; undefined when either part is missing (SDK hosts, minimal test contexts). */
+export function parentModelFullId(model: { provider?: string; id?: string } | undefined): string | undefined {
+	return model?.provider && model.id ? `${model.provider}/${model.id}` : undefined;
+}

package/src/shared/types.ts

@@ -776,6 +776,10 @@ export interface RunSyncOptions {
 	availableModels?: Array<{ provider: string; id: string; fullId: string }>;
 	/** Current parent-session provider to prefer for ambiguous bare model ids */
 	preferredModelProvider?: string;
+	/** Parent session model as provider/id; used when neither the call nor the agent names a model */
+	parentModel?: string;
+	/** Parent session thinking level; used when the agent sets no `thinking` */
+	parentThinking?: string;
 	/** Skills to inject (overrides agent default if provided) */
 	skills?: string[];
 	structuredOutput?: {