@oh-my-pi/pi-coding-agent 9.3.1 → 9.6.0

package/src/prompts/tools/task.md

@@ -1,22 +1,183 @@
 # Task
 
-Launch a new agent to handle complex, multi-step tasks autonomously. Each agent type has specific capabilities and tools available to it.
+Launch agents to handle complex, multi-step tasks autonomously.
 
 <critical>
-This matters. Get it right.
+## Context is everything
 
-Subagents have NO access to conversation history. They only see:
-1. Their agent-specific system prompt
-2. The `context` string you provide
-3. The `task` string you provide
+Subagents fail when context is vague. They cannot read your mind or infer project conventions. Every task needs:
+1. **Goal** - What this accomplishes (one sentence)
+2. **Constraints** - Hard requirements, banned approaches, naming conventions
+3. **Existing Code** - File paths and function signatures to use as patterns
+4. **API Contract** - If the task produces or consumes an interface, spell it out
 
-Use a single Task call with multiple `tasks` entries when parallelizing. Multiple concurrent Task calls bypass coordination.
+Subagents CAN grep the parent conversation file for supplementary details. They CANNOT grep for:
+- Decisions you made but didn't write down
+- Conventions that exist only in your head
+- Which of 50 possible approaches you want
+  **Rule of thumb:** If you'd need to answer a clarifying question for a junior dev to do this task, that information belongs in context.
+</critical>
 
-For code changes, have subagents write files directly with Edit/Write. Do not ask them to return patches for you to apply.
+<context-structure>
+## Required context structure
 
-Agents with `output="structured"` enforce their own schema; the `schema` parameter is ignored for those agents.
-**Never describe expected output in `context` or task descriptions.** All response format requirements go in the `schema` parameter. Use structured schemas with typed properties—not `{ "type": "string" }`. Prose like "respond as a bullet list" is prohibited.
-</critical>
+Use this template. Sections can be omitted only if truly N/A.
+
+````
+## Goal
+[One sentence: what this task accomplishes]
+
+## Constraints
+- [Hard requirements - MUST/MUST NOT style]
+- [API conventions, naming patterns, error handling]
+- [What already exists vs what to create]
+
+## Existing Code
+Reference files the agent MUST read or use as patterns:
+- `path/to/file.ts` - [what pattern it demonstrates]
+- `path/to/other.rs` - [what to reuse from it]
+
+## API Contract (if applicable)
+```language
+// Exact signatures the agent must implement or consume
+fn example(input: Type) -> Result<Output>
+```
+
+## Task
+{{description}}
+
+## Files
+{{files}}
+````
+
+### Bad context (agent will fail or guess wrong)
+
+```
+N-API migration. Keep highlight sync. Use JsString. No WASM.
+Task: {{description}} Files: {{files}}
+```
+
+Why it fails:
+- No existing code to reference - agent doesn't know your patterns
+- No API contract - agent will invent signatures that don't match consumers
+- No goal - agent doesn't know what success looks like
+- "Keep highlight sync" is meaningless without knowing what highlight is or where it lives
+
+### Good context (agent can act confidently)
+
+````
+## Goal
+Port grep module from WASM to N-API, matching existing text module patterns.
+
+## Constraints
+- Use `#[napi]` attribute macro on all exports (not `#[napi(js_name = "...")]`)
+- Return `napi::Result<T>` for fallible ops, never panic
+- Use `spawn_blocking` for any operation that touches filesystem or runs >1ms
+- Accept `JsString` for string params (NOT JsStringUtf8 - it has lifetime issues)
+- Keep all existing function names - TS bindings depend on them
+- No new crate dependencies
+
+## Existing Code
+- `crates/pi-natives/src/text.rs` - reference N-API pattern: see how `visible_width` uses JsString
+- `crates/pi-natives/src/lib.rs` - module registration pattern
+- `crates/pi-natives/Cargo.toml` - available dependencies (ignore, regex already present)
+
+## API Contract
+Current sync API to convert to async:
+```rust
+// BEFORE (sync, blocks event loop)
+#[napi]
+pub fn search(pattern: String, path: String) -> Vec<Match>
+
+// AFTER (async, uses spawn_blocking)
+#[napi]
+pub async fn search(pattern: JsString, path: JsString, env: Env) -> napi::Result<Vec<Match>>
+```
+
+## Task
+{{description}}
+
+## Files
+{{files}}
+````
+</context-structure>
+
+<parallelization>
+## When to parallelize vs sequence
+**The test:** Can agent B write correct code without seeing agent A's output?
+- If YES → parallelize
+- If NO → sequence (A completes, then B runs with A's output in context)
+
+### Dependency patterns that MUST be sequential
+
+|First|Then|Why|
+|---|---|---|
+|Create Rust API|Update TS bindings|Bindings need to know export names and signatures|
+|Define interface/types|Implement consumers|Consumers need the contract|
+|Scaffold with signatures|Implement bodies|Implementations need the shape|
+|Core module|Dependent modules|Dependents import from core|
+
+### Safe to parallelize
+- Independent modules that don't import each other
+- Tests for already-implemented code
+- Documentation for stable APIs
+- Refactors in isolated file scopes
+
+### Phased execution pattern
+
+For migrations/refactors with layers:
+**Phase 1 - Foundation (do yourself or single task):**
+Create the scaffold, define interfaces, establish API shape. Never fan out until the contract is known.
+**Phase 2 - Parallel implementation:**
+Fan out to independent tasks that all consume the same known interface. Include the API contract from Phase 1 in every task's context.
+**Phase 3 - Integration (do yourself):**
+Wire things together, update build/CI, fix any mismatches.
+**Phase 4 - Dependent layer:**
+Fan out again for work that consumes Phase 2 outputs.
+
+### Example: WASM to N-API migration
+**WRONG** (launched together, will fail):
+
+```
+tasks: [
+  { id: "RustApi", description: "Implement N-API exports" },
+  { id: "TsBindings", description: "Update TS to use N-API" },  // ← needs RustApi output!
+]
+```
+**RIGHT** (phased):
+
+```
+// Phase 1: You create scaffold with signatures in lib.rs
+
+// Phase 2: Fan out Rust implementation
+tasks: [
+  { id: "Grep", description: "Implement grep module", args: { files: "src/grep.rs" } },
+  { id: "Text", description: "Implement text module", args: { files: "src/text.rs" } },
+  // Each task gets the API contract you defined in Phase 1
+]
+
+// Phase 3: You verify Rust compiles, exports are correct
+
+// Phase 4: Fan out TS bindings (now they know what Rust exports)
+tasks: [
+  { id: "GrepBindings", description: "Update grep TS", args: { files: "src/grep/index.ts" } },
+  // Context includes actual export names from Phase 2
+]
+```
+</parallelization>
+
+<parameters>
+- `agent`: Agent type for all tasks
+- `context`: Template with `{{placeholders}}`. **Must follow the structure above.** Include Goal, Constraints, Existing Code references. Subagents can search parent context for background, but core requirements must be explicit here.
+- `isolated`: (optional) Run in git worktree, return patches
+- `tasks`: Array of `{id, description, args}`
+  - `id`: CamelCase identifier (max 32 chars)
+  - `description`: What the task does (for logging)
+  - `args`: Object with keys matching `{{placeholders}}` in context
+  - `skills`: (optional) Skill names to preload
+- `schema`: JTD schema for response structure. **Required.** Use typed properties, not `{ "type": "string" }`.
+**Schema goes in `schema` parameter. Never describe output format in `context`.**
+</parameters>
 
 <agents>
 {{#list agents join="\n"}}
@@ -27,66 +188,12 @@ Agents with `output="structured"` enforce their own schema; the `schema` paramet
 {{/list}}
 </agents>
 
-<instruction>
-This matters. Be thorough.
-1. Plan before acting. Define the goal, acceptance criteria, and scope per task.
-2. Put shared constraints and decisions in `context`; keep each task request short and unambiguous. **Do not describe response format here.**
-3. State whether each task is research-only or should modify files.
-4. **Always provide a `schema`** with typed properties. Avoid `{ "type": "string" }`—if data has any structure (list, fields, categories), model it. Plain text is almost never the right choice.
-5. Assign distinct file scopes per task to avoid conflicts.
-6. Trust the returned data, then verify with tools when correctness matters.
-7. The `context` must be self-contained. Paste relevant file contents, quote user requirements verbatim, include data from prior tool results. "The output user showed" means nothing to a subagent.
-</instruction>
-
-<parameters>
-- `agent`: Agent type to use for all tasks
-- `context`: Template with `\{{placeholders}}` for multi-task. Must be self-contained—include all information the subagent needs. Subagents cannot see conversation history, images, or prior tool results. Reproduce relevant content directly: paste file snippets, quote user requirements, embed data. Each placeholder is filled from task args. `\{{id}}` and `\{{description}}` are always available.
-- `isolated`: (optional) Run each task in its own git worktree and return patches; patches are applied only if all apply cleanly.
-- `tasks`: Array of `{id, description, args}` - tasks to run in parallel
-		- `id`: Short CamelCase identifier (max 32 chars, e.g., "SessionStore", "LspRefactor")
-		- `description`: Short human-readable description of what the task does
-		- `args`: Object with keys matching `\{{placeholders}}` in context (always include this, even if empty)
-		- `skills`: (optional) Array of skill names to preload into this task's system prompt. When set, the skills index section is omitted and the full SKILL.md contents are embedded.
-- `schema`: JTD schema defining expected response structure. **Required.** Use objects with typed properties—e.g., `{ "properties": { "items": { "elements": { "type": "string" } } } }` for lists.
-</parameters>
-
-<output>
-Returns task results for each spawned agent:
-- Truncated preview of agent output (use `read agent://<id>` for full content if truncated)
-- Summary with line/character counts
-- For agents with `schema`: structured JSON accessible via `agent://<id>?q=<query>` or `agent://<id>/<path>`
-
-Results are keyed by task `id` (e.g., "AuthProvider", "AuthApi").
-</output>
-
-<example>
-user: "Looks good, execute the plan"
-assistant: I'll execute the refactoring plan.
-assistant: Uses the Task tool:
-{
-  "agent": "task",
-  "context": "Refactoring the auth module into separate concerns.\n\nPlan:\n1. AuthProvider - Extract React context and provider from src/auth/index.tsx\n2. AuthApi - Extract API calls to src/auth/api.ts, use existing fetchJson helper\n3. AuthTypes - Move types to types.ts, re-export from index\n\nConstraints:\n- Preserve all existing exports from src/auth/index.tsx\n- Use project's fetchJson (src/utils/http.ts), don't use raw fetch\n- No new dependencies\n\nTask: \{{step}}\n\nFiles: \{{files}}",
-  "schema": {
-    "properties": {
-      "summary": { "type": "string" },
-      "decisions": { "elements": { "type": "string" } },
-      "concerns": { "elements": { "type": "string" } }
-    }
-  },
-  "tasks": [
-    { "id": "AuthProvider", "description": "Extract React context", "args": { "step": "Execute step 1: Extract AuthProvider and AuthContext", "files": "src/auth/index.tsx" } },
-    { "id": "AuthApi", "description": "Extract API layer", "args": { "step": "Execute step 2: Extract API calls to api.ts", "files": "src/auth/api.ts" } },
-    { "id": "AuthTypes", "description": "Extract types", "args": { "step": "Execute step 3: Move types to types.ts", "files": "src/auth/types.ts" } }
-  ]
-}
-</example>
-
 <avoid>
-- Describing response format in `context` (e.g., "respond as JSON", "return a bullet list")—use `schema` parameter instead
-- Confirmation bias: ask for factual discovery instead of yes/no exploration prompts
-- Reading a specific file path → Use Read tool instead
-- Finding files by pattern/name → Use Find tool instead
-- Searching for a specific class/function definition → Use Grep tool instead
-- Searching code within 2-3 specific files → Use Read tool instead
-- Tasks unrelated to the agent descriptions above
-</avoid>
+- Terse context that requires agents to guess conventions
+- Launching dependent tasks in parallel (bindings + API, consumer + producer)
+- Missing "Existing Code" references - agents need patterns to follow
+- Assuming agents know your codebase - they start fresh each time
+- Describing output format in context instead of schema
+- Single tasks doing too much - prefer focused, file-scoped tasks
+</avoid>
+````

package/src/sdk.ts

@@ -40,7 +40,7 @@ import { getAgentDir, getConfigDirPaths } from "./config";
 import { ModelRegistry } from "./config/model-registry";
 import { formatModelString, parseModelString } from "./config/model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./config/prompt-templates";
-import { type Settings, SettingsManager, type SkillsSettings } from "./config/settings-manager";
+import { Settings, type SkillsSettings } from "./config/settings";
 import { CursorExecHandlers } from "./cursor";
 import "./discovery";
 import { initializeWithSettings } from "./discovery";
@@ -184,8 +184,8 @@ export interface CreateAgentSessionOptions {
 	/** Session manager. Default: SessionManager.create(cwd) */
 	sessionManager?: SessionManager;
 
-	/** Settings manager. Default: SettingsManager.create(cwd, agentDir) */
-	settingsManager?: SettingsManager;
+	/** Settings instance. Default: Settings.init({ cwd, agentDir }) */
+	settingsInstance?: Settings;
 
 	/** Whether UI is available (enables interactive tools like ask). Default: false */
 	hasUI?: boolean;
@@ -210,7 +210,7 @@ export interface CreateAgentSessionResult {
 // Re-exports
 
 export type { PromptTemplate } from "./config/prompt-templates";
-export type { Settings, SkillsSettings } from "./config/settings-manager";
+export { Settings, type SkillsSettings } from "./config/settings";
 export type { CustomCommand, CustomCommandFactory } from "./extensibility/custom-commands/types";
 export type { CustomTool, CustomToolFactory } from "./extensibility/custom-tools/types";
 export type {
@@ -430,33 +430,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	});
 }
 
-// Settings
-
-/**
- * Load settings from agentDir/settings.json merged with cwd/.omp/settings.json.
- */
-export async function loadSettings(cwd?: string, agentDir?: string): Promise<Settings> {
-	const manager = await SettingsManager.create(cwd ?? process.cwd(), agentDir ?? getDefaultAgentDir());
-	return {
-		modelRoles: manager.getModelRoles(),
-		defaultThinkingLevel: manager.getDefaultThinkingLevel(),
-		steeringMode: manager.getSteeringMode(),
-		followUpMode: manager.getFollowUpMode(),
-		interruptMode: manager.getInterruptMode(),
-		theme: manager.getTheme(),
-		compaction: manager.getCompactionSettings(),
-		retry: manager.getRetrySettings(),
-		hideThinkingBlock: manager.getHideThinkingBlock(),
-		shellPath: manager.getShellPath(),
-		shellForceBasic: manager.getShellForceBasic(),
-		collapseChangelog: manager.getCollapseChangelog(),
-		extensions: manager.getExtensionPaths(),
-		skills: manager.getSkillsSettings(),
-		terminal: { showImages: manager.getShowImages() },
-		images: { autoResize: manager.getImageAutoResize(), blockImages: manager.getBlockImages() },
-	};
-}
-
 // Internal Helpers
 
 function createCustomToolContext(ctx: ExtensionContext): CustomToolContext {
@@ -610,14 +583,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const modelRegistry = options.modelRegistry ?? discoverModels(authStorage, agentDir);
 	time("discoverModels");
 
-	const settingsManager = options.settingsManager ?? (await SettingsManager.create(cwd, agentDir));
-	time("settingsManager");
-	initializeWithSettings(settingsManager);
+	const settingsInstance = options.settingsInstance ?? (await Settings.init({ cwd, agentDir }));
+	time("settings");
+	initializeWithSettings(settingsInstance);
 	time("initializeWithSettings");
 
 	// Initialize provider preferences from settings
-	setPreferredWebSearchProvider(settingsManager.getWebSearchProvider());
-	setPreferredImageProvider(settingsManager.getImageProvider());
+	setPreferredWebSearchProvider(settingsInstance.get("providers.webSearch") ?? "auto");
+	setPreferredImageProvider(settingsInstance.get("providers.image") ?? "auto");
 
 	const sessionManager = options.sessionManager ?? SessionManager.create(cwd);
 	time("sessionManager");
@@ -649,7 +622,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// If still no model, try settings default
 	if (!model) {
-		const settingsDefaultModel = settingsManager.getModelRole("default");
+		const settingsDefaultModel = settingsInstance.getModelRole("default");
 		if (settingsDefaultModel) {
 			const parsedModel = parseModelString(settingsDefaultModel);
 			if (parsedModel) {
@@ -689,7 +662,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Fall back to settings default
 	if (thinkingLevel === undefined) {
-		thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? "off";
+		thinkingLevel = settingsInstance.get("defaultThinkingLevel") ?? "off";
 	}
 
 	// Clamp to model capabilities
@@ -705,14 +678,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		skills = options.skills;
 		skillWarnings = [];
 	} else {
-		const discovered = await discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
+		const skillsSettings = settingsInstance.getGroup("skills") as SkillsSettings;
+		const discovered = await discoverSkills(cwd, agentDir, skillsSettings);
 		skills = discovered.skills;
 		skillWarnings = discovered.warnings;
 	}
 	time("discoverSkills");
 
 	// Discover rules
-	const ttsrManager = new TtsrManager(settingsManager.getTtsrSettings());
+	const ttsrSettings = settingsInstance.getGroup("ttsr");
+	const ttsrManager = new TtsrManager(ttsrSettings);
 	const rulesResult = await loadCapability<Rule>(ruleCapability.id, { cwd });
 	for (const rule of rulesResult.items) {
 		if (rule.ttsrTrigger) {
@@ -761,8 +736,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		},
 		getPlanModeState: () => session.getPlanModeState(),
 		getCompactContext: () => session.formatCompactContext(),
-		settings: settingsManager,
-		settingsManager,
+		settings: settingsInstance,
 		authStorage,
 		modelRegistry,
 	};
@@ -777,7 +751,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	internalRouter.register(new ArtifactProtocolHandler({ getArtifactsDir }));
 	internalRouter.register(
 		new PlanProtocolHandler({
-			getPlansDirectory: settingsManager.getPlansDirectory.bind(settingsManager),
+			getPlansDirectory: () => settingsInstance.getPlansDirectory(),
 			cwd,
 		}),
 	);
@@ -814,10 +788,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					);
 				}
 			},
-			enableProjectConfig: settingsManager.getMCPProjectConfigEnabled(),
+			enableProjectConfig: settingsInstance.get("mcp.enableProjectConfig") ?? true,
 			// Always filter Exa - we have native integration
 			filterExa: true,
-			cacheStorage: settingsManager.getStorage(),
+			cacheStorage: settingsInstance.getStorage(),
 		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
@@ -847,11 +821,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("getGeminiImageTools");
 
 	// Add specialized Exa web search tools if EXA_API_KEY is available
-	const exaSettings = settingsManager.getExaSettings();
+	const exaSettings = settingsInstance.getGroup("exa");
 	if (exaSettings.enabled && exaSettings.enableSearch) {
 		const exaWebSearchTools = await getWebSearchTools({
-			enableLinkedin: exaSettings.enableLinkedin,
-			enableCompany: exaSettings.enableCompany,
+			enableLinkedin: exaSettings.enableLinkedin as boolean,
+			enableCompany: exaSettings.enableCompany as boolean,
 		});
 		// Filter out the base web_search (already in built-in tools), add specialized Exa tools
 		const specializedTools = exaWebSearchTools.filter(t => t.name !== "web_search");
@@ -879,12 +853,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		extensionsResult = options.preloadedExtensions;
 	} else {
 		// Merge CLI extension paths with settings extension paths
-		const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...settingsManager.getExtensionPaths()];
+		const configuredPaths = [
+			...(options.additionalExtensionPaths ?? []),
+			...((settingsInstance.get("extensions") as string[]) ?? []),
+		];
 		extensionsResult = await discoverAndLoadExtensions(
 			configuredPaths,
 			cwd,
 			eventBus,
-			settingsManager.getDisabledExtensions(),
+			(settingsInstance.get("disabledExtensions") as string[]) ?? [],
 		);
 		time("discoverAndLoadExtensions");
 		for (const { path, error } of extensionsResult.errors) {
@@ -1006,7 +983,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			tools,
 			toolNames,
 			rules: rulebookRules,
-			skillsSettings: settingsManager.getSkillsSettings(),
+			skillsSettings: settingsInstance.getGroup("skills") as SkillsSettings,
 			isCoordinator: options.hasUI,
 		});
 
@@ -1022,7 +999,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				tools,
 				toolNames,
 				rules: rulebookRules,
-				skillsSettings: settingsManager.getSkillsSettings(),
+				skillsSettings: settingsInstance.getGroup("skills") as SkillsSettings,
 				customPrompt: options.systemPrompt,
 				isCoordinator: options.hasUI,
 			});
@@ -1062,7 +1039,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const convertToLlmWithBlockImages = (messages: AgentMessage[]): Message[] => {
 		const converted = convertToLlm(messages);
 		// Check setting dynamically so mid-session changes take effect
-		if (!settingsManager.getBlockImages()) {
+		if (!settingsInstance.get("images.blockImages")) {
 			return converted;
 		}
 		// Filter out ImageContent from all messages, replacing with text placeholder
@@ -1115,11 +1092,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					return extensionRunner.emitContext(messages);
 				}
 			: undefined,
-		steeringMode: settingsManager.getSteeringMode(),
-		followUpMode: settingsManager.getFollowUpMode(),
-		interruptMode: settingsManager.getInterruptMode(),
-		thinkingBudgets: settingsManager.getThinkingBudgets(),
-		kimiApiFormat: settingsManager.getKimiApiFormat(),
+		steeringMode: settingsInstance.get("steeringMode") ?? "one-at-a-time",
+		followUpMode: settingsInstance.get("followUpMode") ?? "one-at-a-time",
+		interruptMode: settingsInstance.get("interruptMode") ?? "immediate",
+		thinkingBudgets: settingsInstance.getGroup("thinkingBudgets"),
+		kimiApiFormat: settingsInstance.get("providers.kimiApiFormat") ?? "anthropic",
 		getToolContext: tc => toolContextStore.getContext(tc),
 		getApiKey: async () => {
 			const currentModel = agent.state.model;
@@ -1151,7 +1128,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	session = new AgentSession({
 		agent,
 		sessionManager,
-		settingsManager,
+		settings: settingsInstance,
 		scopedModels: options.scopedModels,
 		promptTemplates,
 		slashCommands,
@@ -1159,7 +1136,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		customCommands: customCommandsResult.commands,
 		skills,
 		skillWarnings,
-		skillsSettings: settingsManager.getSkillsSettings(),
+		skillsSettings: settingsInstance.getGroup("skills") as Required<SkillsSettings>,
 		modelRegistry,
 		toolRegistry,
 		rebuildSystemPrompt,
@@ -1169,7 +1146,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Warm up LSP servers (connects to detected servers)
 	let lspServers: CreateAgentSessionResult["lspServers"];
-	if (enableLsp && settingsManager.getLspDiagnosticsOnWrite()) {
+	if (enableLsp && settingsInstance.get("lsp.diagnosticsOnWrite")) {
 		try {
 			const result = await warmupLspServers(cwd, {
 				onConnecting: serverNames => {