mixdog 1.2.1 → 1.2.3

package/src/runtime/agent/orchestrator/providers/xai-tool-search.fixtures.mjs

@@ -0,0 +1,183 @@
+// Shared by xai-tool-search.test.mjs and the one-off generator that produced
+// xai-tool-search-head-parity.json by running these same captures against the
+// pre-change xAI send path. The WebSocket transport is driven through the real
+// sendViaWebSocket with a scripted socket, so the real stream collector and
+// delta framing run; only the connection is replaced.
+import { mock } from 'node:test';
+import { EventEmitter } from 'node:events';
+import * as realWs from './openai-oauth-ws.mjs';
+
+export const ws = { bodies: [], frames: [], scripts: [] };
+
+function scriptedEntry() {
+  const socket = new EventEmitter();
+  socket.readyState = 1;
+  socket.close = () => {
+    socket.readyState = 3;
+  };
+  socket.terminate = socket.close;
+  return { socket, ephemeral: true };
+}
+
+mock.module(new URL('./openai-oauth-ws.mjs', import.meta.url).href, {
+  namedExports: {
+    ...realWs,
+    sendViaWebSocket: (args) => {
+      ws.bodies.push(structuredClone(args.body));
+      return realWs.sendViaWebSocket({
+        ...args,
+        _acquireWithRetryFn: async () => ({ entry: scriptedEntry(), reused: false }),
+        _sendFrameFn: async (entry, frame) => {
+          ws.frames.push(structuredClone(frame));
+          const events = ws.scripts.shift() || [COMPLETED_REPLY];
+          setImmediate(() => {
+            for (const event of events) entry.socket.emit('message', Buffer.from(JSON.stringify(event)));
+          });
+        },
+      });
+    },
+  },
+});
+
+const { sendXaiResponses, sendXaiResponsesWebSocket } = await import('./openai-compat-xai-send.mjs');
+const { nativeHistory, oauthHistory } = await import('./openai-compat-responses-parity.fixtures.mjs');
+export { sendXaiResponses, sendXaiResponsesWebSocket, nativeHistory, oauthHistory };
+
+export const REPLY = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'ok' }] };
+export const COMPLETED_REPLY = {
+  type: 'response.completed',
+  response: { id: 'resp-1', model: 'grok-4', status: 'completed', output: [REPLY] },
+};
+
+// A recorded xAI server-side tool-search turn (shapes per xAI's OpenAPI schema
+// ToolSearchCall / ToolSearchOutput: execution always "server", call_id null).
+export const ENCRYPTED_REASONING = { type: 'reasoning', id: 'rs_1', encrypted_content: 'ENC', summary: [] };
+export const TS_CALL = {
+  type: 'tool_search_call',
+  id: 'tsc_1',
+  call_id: null,
+  execution: 'server',
+  status: 'completed',
+  arguments: { query: 'mcp__weather__forecast', limit: 1 },
+};
+export const TS_OUTPUT = {
+  type: 'tool_search_output',
+  id: 'tso_1',
+  call_id: null,
+  execution: 'server',
+  status: 'completed',
+  tools: [
+    {
+      type: 'function',
+      name: 'mcp__weather__forecast',
+      description: 'Forecast',
+      parameters: { type: 'object', properties: { city: { type: 'string' } } },
+      defer_loading: true,
+    },
+  ],
+};
+export const FN_CALL = {
+  type: 'function_call',
+  id: 'fc_1',
+  call_id: 'call_w',
+  name: 'mcp__weather__forecast',
+  arguments: '{"city":"Seoul"}',
+  status: 'completed',
+};
+export const TURN_OUTPUT = [ENCRYPTED_REASONING, TS_CALL, TS_OUTPUT, FN_CALL];
+
+/** The stream events one server tool-search turn emits, in wire order. */
+export function serverSearchEvents(model = 'grok-4') {
+  return [
+    { type: 'response.created', response: { id: 'resp_ts', model } },
+    { type: 'response.output_item.done', item: ENCRYPTED_REASONING },
+    { type: 'response.output_item.added', item: { ...TS_CALL, status: 'in_progress' } },
+    { type: 'response.output_item.done', item: TS_CALL },
+    { type: 'response.output_item.added', item: TS_OUTPUT },
+    { type: 'response.output_item.done', item: TS_OUTPUT },
+    { type: 'response.output_item.added', item: { ...FN_CALL, arguments: '', status: 'in_progress' } },
+    { type: 'response.function_call_arguments.done', item_id: 'fc_1', arguments: FN_CALL.arguments },
+    { type: 'response.output_item.done', item: FN_CALL },
+    {
+      type: 'response.completed',
+      response: { id: 'resp_ts', model, status: 'completed', output: TURN_OUTPUT },
+    },
+  ];
+}
+
+export const SESSION_TOOLS = [
+  { name: 'Read', description: 'Read a file', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+  { name: 'load_tool', description: 'Load tools', inputSchema: { type: 'object', properties: { names: { type: 'array' } } } },
+];
+export const DEFERRED_TOOLS = [
+  ...SESSION_TOOLS,
+  {
+    name: 'mcp__weather__forecast',
+    description: 'Forecast',
+    inputSchema: { type: 'object', properties: { city: { type: 'string' } } },
+    deferLoading: true,
+  },
+];
+
+export function xaiProvider(config = {}, events = null) {
+  const requests = [];
+  const provider = {
+    name: 'xai',
+    config: { apiKey: 'test-key', preconnect: false, ...config },
+    nativePdf: true,
+    client: {
+      responses: {
+        create: async (params) => {
+          requests.push(structuredClone(params));
+          return (async function* () {
+            for (const event of events || [COMPLETED_REPLY]) yield event;
+          })();
+        },
+      },
+    },
+  };
+  return { provider, requests };
+}
+
+/** The history left by a recorded server tool-search turn (replay owner xai-responses). */
+export function serverSearchHistory() {
+  return [
+    { role: 'user', content: 'weather in Seoul?' },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'call_w', name: 'mcp__weather__forecast', arguments: { city: 'Seoul' } }],
+      providerReplay: { version: 1, provider: 'xai-responses', items: structuredClone(TURN_OUTPUT) },
+    },
+    { role: 'tool', toolCallId: 'call_w', content: 'sunny' },
+    { role: 'user', content: 'and Busan?' },
+  ];
+}
+
+export const CASES = [
+  ['native/plain-tools', () => nativeHistory(), SESSION_TOOLS],
+  ['oauth/plain-tools', () => oauthHistory(), SESSION_TOOLS],
+  ['server-replay/plain-tools', () => serverSearchHistory(), SESSION_TOOLS],
+  ['server-replay/deferred-tools', () => serverSearchHistory(), DEFERRED_TOOLS],
+  ['native/deferred-tools', () => nativeHistory(), DEFERRED_TOOLS],
+];
+
+/** The request body each transport sends for `history`, plus any option overrides. */
+export async function captureBodies(history, tools, { config = {}, opts = {} } = {}) {
+  const http = xaiProvider(config);
+  await sendXaiResponses(http.provider, history, 'grok-4', tools, { sessionId: 'sess-1', ...opts });
+  const before = ws.bodies.length;
+  const socket = xaiProvider(config);
+  await sendXaiResponsesWebSocket(socket.provider, history, 'grok-4', tools, { sessionId: 'sess-1', iteration: 1, ...opts });
+  return { http: http.requests[0], ws: ws.bodies[before] };
+}
+
+export async function captureAll() {
+  const out = {};
+  for (const [label, build, tools] of CASES) {
+    const { http, ws: socketBody } = await captureBodies(build(), tools);
+    out[`http/${label}`] = http;
+    out[`ws/${label}`] = socketBody;
+  }
+  return out;
+}

package/src/runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs

@@ -0,0 +1,100 @@
+export const ASK_USER_MAX_QUESTIONS = 4;
+export const ASK_USER_MAX_TEXT = 4000;
+export const ASK_USER_MAX_LABEL = 80;
+
+export const ASK_USER_TOOL_DEFS = Object.freeze([
+  {
+    name: 'ask_user',
+    title: 'Ask User',
+    trigger: 'Ask the user 1–4 multiple-choice questions and wait; when a plan needs the user to pick between clear options, instead of listing them in chat.',
+    description:
+      'Ask the user multiple-choice questions and wait. Only while planning, for a decision only the user can make with clear options; open questions, minor choices and plan approval go in chat. Do not repeat the options in your message.',
+    annotations: {
+      title: 'Ask User',
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      agentHidden: true,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        questions: {
+          type: 'array',
+          minItems: 1,
+          maxItems: ASK_USER_MAX_QUESTIONS,
+          items: {
+            type: 'object',
+            properties: {
+              question: { type: 'string', description: 'Full question, without the options.' },
+              header: { type: 'string', maxLength: 12, description: 'Chip label.' },
+              options: {
+                type: 'array',
+                minItems: 2,
+                maxItems: 4,
+                description: 'Distinct; free text is added, never "Other".',
+                items: {
+                  type: 'object',
+                  properties: {
+                    label: { type: 'string', maxLength: 80, description: '1-5 words.' },
+                    description: { type: 'string', description: 'One-sentence tradeoff.' },
+                  },
+                  required: ['label', 'description'],
+                  additionalProperties: false,
+                },
+              },
+              multi_select: { type: 'boolean' },
+              recommended: { type: 'integer', minimum: 0, description: 'Recommended option index.' },
+            },
+            required: ['question', 'header', 'options'],
+          },
+        },
+      },
+      required: ['questions'],
+      additionalProperties: false,
+    },
+  },
+]);
+
+/** Throws a clear error when the questions are malformed; returns the list. */
+export function validateAskUserQuestions(args) {
+  const questions = args?.questions;
+  if (!Array.isArray(questions) || questions.length < 1 || questions.length > ASK_USER_MAX_QUESTIONS) {
+    throw new Error(`ask_user requires 1-${ASK_USER_MAX_QUESTIONS} questions`);
+  }
+  const seenQuestions = new Set();
+  questions.forEach((q, i) => {
+    const at = `ask_user question ${i + 1}`;
+    if (!q || typeof q !== 'object') throw new Error(`${at} must be an object`);
+    if (typeof q.question !== 'string' || !q.question.trim()) throw new Error(`${at} needs question text`);
+    if (typeof q.header !== 'string' || !q.header.trim() || q.header.length > 12) {
+      throw new Error(`${at} needs a header of at most 12 characters`);
+    }
+    if (seenQuestions.has(q.question)) throw new Error(`${at} duplicates another question text`);
+    seenQuestions.add(q.question);
+    if (!Array.isArray(q.options) || q.options.length < 2 || q.options.length > 4) {
+      throw new Error(`${at} needs 2-4 options`);
+    }
+    const labels = new Set();
+    for (const option of q.options) {
+      if (!option || typeof option.label !== 'string' || !option.label.trim()) {
+        throw new Error(`${at} has an option without a label`);
+      }
+      if (option.label.length > 80) throw new Error(`${at} has an option label over 80 characters`);
+      if (typeof option.description !== 'string' || !option.description.trim()) {
+        throw new Error(`${at} option "${option.label}" needs a one-sentence description`);
+      }
+      if (option.description.length > 200) throw new Error(`${at} has an option description over 200 characters`);
+      if (Object.keys(option).some((key) => key !== 'label' && key !== 'description')) {
+        throw new Error(`${at}: options take only a label and a description`);
+      }
+      if (labels.has(option.label)) throw new Error(`${at} has duplicate option label "${option.label}"`);
+      labels.add(option.label);
+    }
+    if (q.recommended != null && (!Number.isInteger(q.recommended) || q.recommended < 0 || q.recommended >= q.options.length)) {
+      throw new Error(`${at} recommended must be an index below ${q.options.length}`);
+    }
+  });
+  return questions;
+}

package/src/runtime/agent/orchestrator/runtime-core/config-helpers.mjs

@@ -351,6 +351,9 @@ export function normalizeCompactionConfig(value = {}) {
   return {
     ...next,
     auto: raw.auto !== false && raw.enabled !== false,
+    // Compact a conversation on its current model before switching it to
+    // another one in place (default on).
+    onModelChange: raw.onModelChange !== false,
   };
 }
 

package/src/runtime/agent/orchestrator/runtime-core/deferred-tool-availability.mjs

@@ -1,3 +1,24 @@
+const lowerName = (name) => String(name || '').toLowerCase();
+
+/** The persisted schema allowlist (also the execution allowlist) leaves `name` out. */
+export function sessionAllowlistExcludes(session, name) {
+  if (!Array.isArray(session?.schemaAllowedTools)) return false;
+  return !session.schemaAllowedTools.some((allowed) => lowerName(allowed) === lowerName(name));
+}
+
+/** The session's denied tools name `name`. */
+export function sessionDisallows(session, name) {
+  return Array.isArray(session?.disallowedTools) && session.disallowedTools.some((denied) => lowerName(denied) === lowerName(name));
+}
+
+/**
+ * The session's own tool policy permits `name`: discovery (load_tool by name
+ * or query) shows, selects and describes only what execution would run.
+ */
+export function isToolPermittedBySessionPolicy(session, name) {
+  return !sessionAllowlistExcludes(session, name) && !sessionDisallows(session, name);
+}
+
 // Discovery history retains definitions; only the latest scoped MCP snapshot
 // grants availability. An absent snapshot preserves pre-initialization behavior.
 export function isDeferredToolAvailable(session, name) {

package/src/runtime/agent/orchestrator/runtime-core/effort.mjs

@@ -114,6 +114,21 @@ function catalogEffortOptions(provider, model) {
   return providerAllowed ? [...providerAllowed] : [];
 }
 
+const warnedEmptyLadders = new Set();
+
+/**
+ * Auto effort skipped a judgment because the base is off the model's ladder.
+ * A user-chosen max/ultra is expected to skip; any other base means the route
+ * has no usable ladder, so say so once per provider/model per process.
+ */
+export function warnEmptyAutoEffortLadder(provider, model, base) {
+  if (base === 'max' || base === 'ultra') return;
+  const key = `${provider}/${model}`;
+  if (warnedEmptyLadders.has(key)) return;
+  warnedEmptyLadders.add(key);
+  process.stderr.write(`[auto-effort] no effort ladder for ${key}; judge skipped\n`);
+}
+
 export function coerceEffortFor(provider, model, effort) {
   if (!effort) return null;
   if (model?.customReasoning) return snapCustomEffort(customEffortLevels(model), effort);

package/src/runtime/agent/orchestrator/runtime-core/goal-reminder.mjs

@@ -80,21 +80,3 @@ export function acknowledgePendingGoalReminder(session, revision) {
   session.updatedAt = Date.now();
   return true;
 }
-
-export function prependGoalReminderToLatestUserMessage(messages, content) {
-  const reminder = clean(content);
-  const out = Array.isArray(messages) ? [...messages] : [];
-  if (!reminder) return out;
-  for (let index = out.length - 1; index >= 0; index -= 1) {
-    const message = out[index];
-    if (message?.role !== 'user') continue;
-    const current = message.content;
-    const nextContent = Array.isArray(current)
-      ? [{ type: 'text', text: `${reminder}\n\n` }, ...current]
-      : `${reminder}\n\n${String(current ?? '')}`;
-    out[index] = { ...message, content: nextContent };
-    return out;
-  }
-  out.push({ role: 'user', content: reminder });
-  return out;
-}

package/src/runtime/agent/orchestrator/runtime-core/model-capabilities.mjs

@@ -7,6 +7,7 @@ import { modelSupportsServiceTier } from '../providers/model-service-tiers.mjs';
 import { openAiDirectSupportsFast, openAiDirectSupportsUltrafast } from '../providers/openai-direct-request.mjs';
 import { supportsAnthropicFastMode } from '../../../shared/llm/anthropic-betas.mjs';
 import { normalizeContextTokens } from '../../../shared/llm/default-context-window.mjs';
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
 
 const FAST_CAPABLE_PROVIDERS = new Set([
   'anthropic',
@@ -24,41 +25,59 @@ export function routeFastKey(provider, model) {
   return p && m ? `${p}/${m}` : '';
 }
 
-function openAiModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id) return false;
-  if (model?.supportsWebSearch === true) return true;
+// What one catalog row states about hosted web search: its own
+// `supportsWebSearch` flag (true or false), else a web_search tool in its tool
+// lists. Null when the row says nothing, which leaves the answer to the id
+// fallback of each family.
+function rowWebSearchDeclaration(row) {
+  if (!row || typeof row !== 'object') return null;
+  if (typeof row.supportsWebSearch === 'boolean') return row.supportsWebSearch;
   const tools = [
-    ...(Array.isArray(model?.supportedTools) ? model.supportedTools : []),
-    ...(Array.isArray(model?.tools) ? model.tools : []),
-    ...(Array.isArray(model?.capabilities?.tools) ? model.capabilities.tools : []),
+    ...(Array.isArray(row.supportedTools) ? row.supportedTools : []),
+    ...(Array.isArray(row.tools) ? row.tools : []),
+    ...(Array.isArray(row.capabilities?.tools) ? row.capabilities.tools : []),
   ].map((tool) => clean(tool?.type || tool?.name || tool).toLowerCase());
-  if (tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview')) return true;
-  if (/codex|image|audio|tts|stt|embedding|rerank|moderation|search-preview/.test(id)) return false;
-  return /^gpt-(5(?:\.|$|-)|4\.1(?:-|$)|4o(?:-|$)|4\.5(?:-|$))/.test(id) || /^o[34](?:-|$)/.test(id);
-}
-
-function grokModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id || /imagine|image|video|composer/.test(id)) return false;
-  if (id === 'grok-build') return false;
-  return /^grok-/.test(id);
+  return tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview') ? true : null;
 }
 
-function geminiModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id || /embedding|aqa|imagen|veo|tts|image|computer-use|customtools/.test(id)) return false;
-  return /^gemini-(3(?:\.|-|$)|2\.5-|2\.0-flash)/.test(id);
+// The route's own row first, then the provider catalog's row for the model.
+function hostedWebSearchDeclared(model, catalogRow) {
+  return rowWebSearchDeclaration(model) ?? rowWebSearchDeclaration(catalogRow);
 }
 
-function anthropicModelSupportsHostedWebSearch(model) {
+// When neither the route row nor the catalog states hosted web search, the
+// vendor family (already fixed by the provider) is taken as capable unless the
+// id names a non-chat modality or a retired generation. Only those closed,
+// frozen sets are matched by id, so a model released later needs no entry here;
+// guessing "capable" wrongly would hard-fail the request, which is why the
+// retired generations stay excluded.
+function hostedWebSearchFallback(model, catalogRow, unsupportedId) {
   const id = clean(model?.id || model).toLowerCase();
   if (!id) return false;
-  const match = id.match(/^claude-(opus|sonnet|haiku|fable|mythos)-(\d+)(?:[-.](\d+))?/);
-  if (!match) return false;
-  return (Number(match[2]) || 0) >= 4;
+  const declared = hostedWebSearchDeclared(model, catalogRow);
+  if (declared !== null) return declared;
+  return !unsupportedId.test(id);
 }
 
+const NON_CHAT_ID = 'embedding|rerank|moderation|image|imagen|imagine|video|veo|audio|tts|stt|aqa|search-preview';
+
+const OPENAI_UNSUPPORTED = new RegExp(
+  `${NON_CHAT_ID}|codex|^gpt-(?:3|4(?:$|-))|^o[12](?:-|$)|^(?:babbage|davinci|text-)`
+);
+const GROK_UNSUPPORTED = new RegExp(`${NON_CHAT_ID}|composer|^grok-build$|^grok-[123](?:[.-]|$)`);
+// The Gemini family is also reached through a relay serving other vendors'
+// models, whose hosted search is Gemini's alone, so a non-Gemini id is out.
+const GEMINI_UNSUPPORTED = new RegExp(
+  `${NON_CHAT_ID}|^(?!gemini-)|computer-use|customtools|^gemini-(?:1[.-]|pro|ultra)|^gemini-2\\.0-(?!flash)`
+);
+const ANTHROPIC_UNSUPPORTED = /^claude-(?:\d|instant)|^claude-[a-z]+-[123](?:[-.]|$)/;
+
+const openAiModelSupportsHostedWebSearch = (model, row) => hostedWebSearchFallback(model, row, OPENAI_UNSUPPORTED);
+const grokModelSupportsHostedWebSearch = (model, row) => hostedWebSearchFallback(model, row, GROK_UNSUPPORTED);
+const geminiModelSupportsHostedWebSearch = (model, row) => hostedWebSearchFallback(model, row, GEMINI_UNSUPPORTED);
+const anthropicModelSupportsHostedWebSearch = (model, row) =>
+  hostedWebSearchFallback(model, row, ANTHROPIC_UNSUPPORTED);
+
 export function fastCapableFor(provider, model, effort = null, modelParameters = {}) {
   const p = clean(provider);
   if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
@@ -77,8 +96,13 @@ export function fastCapableFor(provider, model, effort = null, modelParameters =
     }
     return !selectedEffort || fastEfforts.length === 0 || fastEfforts.includes(selectedEffort);
   }
-  if (p === 'openai') return openAiDirectSupportsFast(model);
   if (p === 'openai-oauth') return modelSupportsServiceTier(model, 'priority');
+  // The route row's own declaration first, then the catalog via the helpers.
+  if (typeof model?.supportsFastMode === 'boolean') return model.supportsFastMode;
+  const modelId = clean(model?.id || model);
+  const declaredFast = modelId ? getModelMetadataSync(modelId, p)?.supportsFastMode : undefined;
+  if (typeof declaredFast === 'boolean') return declaredFast;
+  if (p === 'openai') return openAiDirectSupportsFast(model);
   if (p === 'anthropic' || p === 'anthropic-oauth') return supportsAnthropicFastMode(clean(model?.id || model));
   return false;
 }
@@ -100,10 +124,15 @@ const HOSTED_WEB_SEARCH_BY_FAMILY = {
 // webSearchCapableFor needs the web-search family mapping, which lives in
 // workflow.mjs and is pure. Wire it in via a factory to keep this module free
 // of a circular import at load time.
-export function makeWebSearchCapableFor(webSearchProviderFamily) {
+// `catalogRowFor(provider, id)` is the provider catalog's row for the model;
+// callers that hold only a bare id (or a row the provider list left silent)
+// still get the catalog's answer before the id fallback applies.
+export function makeWebSearchCapableFor(webSearchProviderFamily, catalogRowFor = getModelMetadataSync) {
   return function webSearchCapableFor(provider, model) {
     const supports = HOSTED_WEB_SEARCH_BY_FAMILY[webSearchProviderFamily(provider)];
-    return supports ? supports(model) : false;
+    if (!supports) return false;
+    const id = clean(model?.id || model);
+    return supports(model, id ? catalogRowFor(id, provider) : null);
   };
 }
 

package/src/runtime/agent/orchestrator/runtime-core/orchestration.mjs

@@ -2,16 +2,14 @@ import { normalizeOrchestrationMode } from '../../../shared/orchestration.mjs';
 
 const BATCHING = {
   focused: `Lead executes the main scope directly. Delegate only substantial,
-self-contained supporting work. Batch closely related tasks into one
-coherent assignment; do not split them merely to increase parallelism.`,
-  balanced: `Delegate independent work by coherent feature or module. Batch related
-tasks within the same change scope into one assignment rather than
-splitting every file or step.
-If the plan has only one scope, Lead executes it directly.`,
-  swarm: `Delegate every substantial independent scope to its own agent. Treat
-disjoint file or module sets as independent and merge scopes only on a true
-output dependency. Prefer parallel scopes over sequential slices in one agent.
-If the plan has only one scope, Lead executes it directly.`,
+self-contained supporting work, one agent per role; batch related tasks
+rather than splitting them for parallelism.`,
+  balanced: `Delegate independent work by coherent feature or module, one agent per
+scope. Batch related tasks within the same change scope rather than
+splitting every file or step.`,
+  swarm: `Delegate every independent scope to its own agent. Treat disjoint file or
+module sets as independent and merge scopes only on a true output
+dependency. Prefer parallel scopes over sequential slices in one agent.`,
 };
 
 const SOLO = `# Orchestration Mode: Solo
@@ -27,6 +25,12 @@ export function orchestrationInstructions(value) {
 
 ${BATCHING[mode]}
 
+The mode sets how work splits; an agent's description sets its role and when
+it runs. Splitting applies to every role alike — implementation, review,
+investigation, writing — by file, module, commit range or risk area.
+If the plan has only one implementation scope, Lead executes it directly; a
+role tied to a point in the work, such as the final check, still runs then.
+
 Delegation is for work whose size justifies a brief. When the brief would have
 to spell out the edits themselves — a few localized changes whose sites Lead
 already holds — Lead makes them directly in every mode; the number of files or
@@ -34,10 +38,9 @@ scopes does not change this.
 
 Dispatch all ready independent scopes in one turn. Only a scope that requires
 another's output waits. Brief each agent as the Lead rules describe.
-Use only available agents; Lead handles work without a suitable agent.
-
-If the reviewer is disabled or unavailable, Lead alone reviews the result
-against the approved scope and performs the required verification. Do not
-change settings, enable the reviewer, or delegate review to a substitute agent.
-Do not skip review or describe Lead's own review as independent review.`;
+Use only available agents; when none fits a role, Lead does that work itself
+and never changes settings to enable one. If the reviewer is disabled or
+unavailable, Lead alone reviews the result against the approved scope and
+performs the required verification, without a substitute agent; never skip
+review or describe Lead's own review as independent.`;
 }

package/src/runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs

@@ -1,17 +1,5 @@
 // Plugin/project MCP server discovery + normalization, and skill-file counting.
-import {
-  chmodSync,
-  closeSync,
-  existsSync,
-  fsyncSync,
-  openSync,
-  readFileSync,
-  readdirSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 import { clean } from './session-text.mjs';
 import {
@@ -54,90 +42,6 @@ export function mergeMcpServerConfig(existing, next) {
   return { ...merged, ...next };
 }
 
-function readProjectMcpDocument(cwd, allowMissing = false) {
-  const path = join(cwd || '.', '.mcp.json');
-  if (!existsSync(path)) {
-    if (allowMissing) return { path, raw: { mcpServers: {} }, usesWrapper: true };
-    throw new Error(`MCP config file not found: ${path}`);
-  }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(path, 'utf8'));
-  } catch (error) {
-    throw new Error(`cannot read ${path}: ${error?.message || String(error)}`);
-  }
-  if (!isPlainObject(raw)) throw new Error(`unexpected .mcp.json shape at ${path}`);
-  if (Object.hasOwn(raw, 'mcpServers') && !isPlainObject(raw.mcpServers)) {
-    throw new Error(`unexpected .mcp.json shape at ${path}`);
-  }
-  const usesWrapper = isPlainObject(raw.mcpServers);
-  return { path, raw, usesWrapper };
-}
-
-function writeProjectMcpDocument(path, raw) {
-  let mode = 0o644;
-  try {
-    mode = statSync(path).mode;
-  } catch {
-    /* new file */
-  }
-  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
-  let fd = null;
-  try {
-    fd = openSync(tempPath, 'w', mode);
-    writeFileSync(fd, `${JSON.stringify(raw, null, 2)}\n`, 'utf8');
-    fsyncSync(fd);
-    closeSync(fd);
-    fd = null;
-    chmodSync(tempPath, mode);
-    renameSync(tempPath, path);
-  } catch (error) {
-    if (fd !== null) {
-      try {
-        closeSync(fd);
-      } catch {
-        /* best effort */
-      }
-    }
-    try {
-      unlinkSync(tempPath);
-    } catch {
-      /* best effort */
-    }
-    throw error;
-  }
-}
-
-// The stored key for `key`: an exact own key first, else one that trims to it.
-function mcpEntryKey(map, key) {
-  return Object.hasOwn(map, key) ? key : Object.keys(map).find((candidate) => String(candidate || '').trim() === key);
-}
-
-export function readProjectMcpServerConfig(cwd, name) {
-  const { raw, usesWrapper } = readProjectMcpDocument(cwd);
-  const map = usesWrapper ? raw.mcpServers : raw;
-  const entryKey = mcpEntryKey(map, String(name || '').trim());
-  return entryKey && isPlainObject(map[entryKey]) ? { name: entryKey, config: { ...map[entryKey] } } : null;
-}
-
-export function saveProjectMcpServer(cwd, { originalName = '', name, config }) {
-  const { path, raw, usesWrapper } = readProjectMcpDocument(cwd, !originalName);
-  const map = usesWrapper ? raw.mcpServers : raw;
-  const target = String(name || '').trim();
-  const original = String(originalName || '').trim();
-  if (!target) throw new Error('MCP server name is required');
-  const entryKey = original ? mcpEntryKey(map, original) : null;
-  if (original && !entryKey) throw new Error(`MCP server not defined in ${path}: ${original}`);
-  if (target !== entryKey && Object.hasOwn(map, target)) {
-    throw new Error(`MCP server already exists in ${path}: ${target}`);
-  }
-  const existing = entryKey ? map[entryKey] : {};
-  if (entryKey && entryKey !== target) delete map[entryKey];
-  map[target] = mergeMcpServerConfig(existing, config);
-  writeProjectMcpDocument(path, raw);
-  return { name: target, source: 'project', path, config: { ...map[target] } };
-}
-
 // Manifest + contained-path resolution live in the shared module so skill
 // discovery and this status surface read the same roots.
 export { pluginManifest, resolveContainedPluginPath };