mixdog 1.2.5 → 1.3.0

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -8,6 +8,7 @@ import { noEnabledProvidersError } from './registry-errors.mjs';
 import { providerTakesNativePdf } from '../../../attachments/store.mjs';
 import { modelProxyClientMode } from '../../../shared/model-proxy-mode.mjs';
 import { getModelProxyChannel } from './model-proxy-channel.mjs';
+import { boundedProviderCatalogOp } from './catalog-deadline.mjs';
 // OpenAI-compat provider names are self-declared by openai-compat-presets.mjs via
 // OPENAI_COMPAT_PRESETS. No parallel list maintained here.
 const providers = new Map();
@@ -33,6 +34,7 @@ export const OAUTH_PROVIDER_NAMES = new Set([
   'mimo-oauth',
   'cursor-oauth',
   'antigravity-oauth',
+  'opencode-go-oauth',
 ]);
 // Providers the most recently applied config declared with enabled:false for a
 // USER reason. A deliberate opt-out (logout / disable in settings) must survive
@@ -178,7 +180,7 @@ const PROVIDER_MODULES = {
   'cursor-api': ['./cursor.mjs', 'CursorApiProvider'],
   openai: ['./openai-ws.mjs', 'OpenAIDirectProvider'],
   'mixdog-local': ['./mixdog-local.mjs', 'MixdogLocalProvider'],
-  'opencode-go': ['./opencode-go.mjs', 'OpenCodeGoProvider'],
+  'opencode-go-oauth': ['./opencode-go-oauth.mjs', 'OpenCodeGoOAuthProvider'],
   // Multi-wire preset gateways (wire-route.mjs picks the wire per model).
   openrouter: ['./openrouter.mjs', 'OpenRouterProvider'],
   deepseek: ['./deepseek.mjs', 'DeepSeekProvider'],
@@ -288,6 +290,8 @@ async function _initProvidersUnsynchronized(config, signal = null, proxyChannel
   const enabledResults = await Promise.all(
     entries.map(async ([name, cfg]) => {
       if (!cfg.enabled) return null;
+      // A retired provider's saved config is inert: its replacement is its own entry.
+      if (Object.hasOwn(RETIRED_PROVIDER_ALIASES, name)) return null;
       // Idempotent reuse: an enabled provider whose config signature is
       // unchanged from the live registry is carried forward as-is. Only
       // added or changed providers are (re)constructed below.
@@ -438,7 +442,14 @@ function _scheduleOAuthSelfHeal(name) {
       _oauthSelfHealLoads.delete(name);
     });
 }
-export function getProvider(name) {
+// Provider ids that were retired: a saved route or session naming one is served
+// by its replacement account. When that account is not connected the lookup
+// misses like any other unconnected provider.
+const RETIRED_PROVIDER_ALIASES = Object.freeze({ 'opencode-go': 'opencode-go-oauth' });
+export function getProvider(requestedName) {
+  const name = Object.hasOwn(RETIRED_PROVIDER_ALIASES, requestedName)
+    ? RETIRED_PROVIDER_ALIASES[requestedName]
+    : requestedName;
   const cached = providers.get(name);
   if (cached) return cached;
   // OAuth lazy fallback. Covers the boot-time race where the credential probe
@@ -560,10 +571,23 @@ export async function _withRegisteredProviderForTestAsync(name, instance, fn) {
 // Shared by the startup refresh and the 24h/forced refresh below.
 function providerCatalogRefreshFn(provider) {
   if (typeof provider?._refreshModelCache === 'function') return () => provider._refreshModelCache();
-  if (typeof provider?.listModels === 'function') return () => provider.listModels();
+  if (typeof provider?.listModels === 'function') return (signal) => provider.listModels({ signal });
   return null;
 }
 
+// One provider's refresh, bounded per provider (catalog-deadline.mjs): a hung
+// or offline provider is reported and left out after the deadline, so the
+// refresh epoch still completes for everyone else. Its late answer lands in
+// its own model cache; the session catalog retries its listing after the
+// partial-catalog backoff.
+function boundedCatalogRefresh(name, provider, refreshFn, label) {
+  return boundedProviderCatalogOp({ name, provider, kind: 'refresh', run: refreshFn }).then(({ error }) => {
+    if (!error) return;
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[provider:${name}] ${label} failed: ${msg}\n`);
+  });
+}
+
 function armNextCatalogRefresh(startedAt = Date.now()) {
   _catalogRefreshNotBefore = startedAt + CATALOG_REFRESH_INTERVAL_MS;
   if (_catalogRefreshTimer) clearTimeout(_catalogRefreshTimer);
@@ -589,14 +613,7 @@ export function refreshProviderCatalogsOnStartup() {
   for (const [name, provider] of providers) {
     const refreshFn = providerCatalogRefreshFn(provider);
     if (!refreshFn) continue;
-    pending.push(
-      Promise.resolve()
-        .then(() => refreshFn())
-        .catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[provider:${name}] startup catalog refresh failed: ${msg}\n`);
-        })
-    );
+    pending.push(boundedCatalogRefresh(name, provider, refreshFn, 'startup catalog refresh'));
   }
   // Returns a completion promise so callers can invalidate stale model
   // caches once the fresh catalogs land. Still fire-and-forget: unawaited
@@ -621,25 +638,22 @@ export function refreshCatalogs(options = {}) {
   }
   armNextCatalogRefresh();
   const pending = [];
-  const metadataReady = Promise.resolve()
-    .then(() => refreshMetadataCatalog())
-    .catch((err) => {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[model-catalog] metadata refresh failed: ${msg}\n`);
-      return null;
-    });
+  // The shared metadata fetch is bounded the same way: providers wait for it
+  // at most one deadline before refreshing without fresh metadata.
+  const metadataReady = boundedProviderCatalogOp({
+    name: '(model-metadata)',
+    provider: null,
+    kind: 'refresh',
+    run: () => refreshMetadataCatalog(),
+  }).then(({ error }) => {
+    if (!error) return;
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[model-catalog] metadata refresh failed: ${msg}\n`);
+  });
   for (const [name, provider] of providers) {
     const refreshFn = providerCatalogRefreshFn(provider);
     if (!refreshFn) continue;
-    pending.push(
-      Promise.resolve()
-        .then(() => metadataReady)
-        .then(() => refreshFn())
-        .catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[provider:${name}] catalog refresh failed: ${msg}\n`);
-        })
-    );
+    pending.push(metadataReady.then(() => boundedCatalogRefresh(name, provider, refreshFn, 'catalog refresh')));
   }
   // Completion promise: lets callers drop stale model caches after refresh.
   _catalogRefreshPromise = Promise.allSettled([metadataReady, ...pending])

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

@@ -1,6 +1,7 @@
-export const ASK_USER_MAX_QUESTIONS = 4;
+import { loginPageUrl } from '../session/human-gate/requests.mjs';
+
+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([
   {
@@ -9,7 +10,7 @@ export const ASK_USER_TOOL_DEFS = Object.freeze([
     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.',
+      'Ask the user multiple-choice questions and wait. Only for a decision only the user can make, with clear options; never for minor choices or approval of requested work, and open questions go in chat. Do not repeat the options in your message.',
     annotations: {
       title: 'Ask User',
       readOnlyHint: true,
@@ -51,13 +52,106 @@ export const ASK_USER_TOOL_DEFS = Object.freeze([
             required: ['question', 'header', 'options'],
           },
         },
+        handoff: {
+          type: 'object',
+          description:
+            'Instead of questions: secret = the user types a password/token into the focused field (you never see it; result provided/skipped/timeout); takeover = the user does a step (sign-in, CAPTCHA, 2FA) and says done.',
+          properties: {
+            kind: { type: 'string', enum: ['secret', 'takeover'] },
+            surface: { type: 'string', enum: ['browser', 'computer'] },
+            target: { type: 'string', maxLength: 200, description: 'Site/app and form.' },
+            field: { type: 'string', maxLength: 80, description: 'secret: field label.' },
+            instructions: { type: 'string', maxLength: 2000, description: 'takeover: what to do.' },
+            need: {
+              type: 'string',
+              enum: ['sign_in', 'action', 'confirmation'],
+              description:
+                'takeover: sign_in (sign-in, 2FA), action (CAPTCHA, other step), confirmation (identity/payment check). Default action.',
+            },
+            purpose: {
+              type: 'string',
+              enum: ['login'],
+              description: 'browser takeover: login = sign-in window on url.',
+            },
+            url: { type: 'string', maxLength: 2048, description: 'login: sign-in page (https).' },
+            tab: { type: 'string', maxLength: 64, description: 'browser takeover: page ID from list_tabs.' },
+            window_id: { type: 'string', maxLength: 128, description: 'computer takeover: exact window id.' },
+            app: { type: 'string', maxLength: 120, description: 'computer takeover: app name.' },
+          },
+          required: ['kind', 'surface'],
+          additionalProperties: false,
+        },
       },
-      required: ['questions'],
       additionalProperties: false,
     },
   },
 ]);
 
+/** The handoff of an ask_user call ({ kind, surface, target, field, instructions }), or null. */
+export function validateAskUserHandoff(args) {
+  const handoff = args?.handoff;
+  if (handoff == null) return null;
+  if (args.questions != null) throw new Error('ask_user takes questions or a handoff, not both');
+  if (typeof handoff !== 'object' || Array.isArray(handoff)) throw new Error('ask_user handoff must be an object');
+  if (handoff.kind !== 'secret' && handoff.kind !== 'takeover') {
+    throw new Error('ask_user handoff kind is secret or takeover');
+  }
+  if (handoff.surface !== 'browser' && handoff.surface !== 'computer') {
+    throw new Error('ask_user handoff surface is browser or computer');
+  }
+  const text = (key, limit) => (typeof handoff[key] === 'string' ? handoff[key].trim().slice(0, limit) : '');
+  if (handoff.kind === 'takeover' && !text('instructions', 2000)) {
+    throw new Error('ask_user takeover needs instructions');
+  }
+  const login = handoffLogin(handoff);
+  let need = login ? 'sign_in' : 'action';
+  if (['sign_in', 'action', 'confirmation'].includes(handoff.need)) need = handoff.need;
+  return {
+    kind: handoff.kind,
+    surface: handoff.surface,
+    target: text('target', 200),
+    field: text('field', 80),
+    instructions: text('instructions', 2000),
+    ...(handoff.kind === 'takeover' ? { need, identity: handoffIdentity(handoff), ...(login ? { login } : {}) } : {}),
+  };
+}
+
+/** A login takeover's sign-in page ({ url, origin }); null without the
+ *  explicit purpose, so every other takeover keeps the side panel. */
+function handoffLogin(handoff) {
+  if (handoff.purpose == null) return null;
+  if (handoff.purpose !== 'login' || handoff.kind !== 'takeover' || handoff.surface !== 'browser') {
+    throw new Error('ask_user purpose login is a browser takeover');
+  }
+  const page = loginPageUrl(handoff.url);
+  if (!page) throw new Error('ask_user login needs an https url (http only on localhost)');
+  return page;
+}
+
+/** The window a takeover is about, validated per surface: a browser page ID
+ *  (list_tabs p1, v1 or a page name) or a computer window id and app. Shapes
+ *  that are not plain tokens are dropped, never passed on. */
+const TOKEN = /^[\w.:#@-]+$/;
+function handoffIdentity(handoff) {
+  const token = (key, limit) => {
+    const value = typeof handoff[key] === 'string' ? handoff[key].trim() : '';
+    return value && value.length <= limit && TOKEN.test(value) ? value : '';
+  };
+  if (handoff.surface === 'browser') {
+    const tab = token('tab', 64);
+    return tab ? { tab } : {};
+  }
+  const windowId = token('window_id', 128);
+  const app =
+    typeof handoff.app === 'string'
+      ? handoff.app
+          .replace(/[\r\n]+/g, ' ')
+          .trim()
+          .slice(0, 120)
+      : '';
+  return { ...(windowId ? { windowId } : {}), ...(app ? { app } : {}) };
+}
+
 /** Throws a clear error when the questions are malformed; returns the list. */
 export function validateAskUserQuestions(args) {
   const questions = args?.questions;

package/src/runtime/agent/orchestrator/runtime-core/context-status-shape.mjs

@@ -46,6 +46,7 @@ export function sessionTokenCounters(session) {
     totalOutputTokens: Number(session?.totalOutputTokens || 0),
     totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
     totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+    usageReadout: session?.usageReadout || null,
     compactBoundaryTokens: Number(session?.compactBoundaryTokens || 0),
   };
 }
@@ -64,6 +65,9 @@ function sessionUsageCounters(session, lastContextTokens) {
     totalOutputTokens: Number(session?.totalOutputTokens || 0),
     totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
     totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+    // Session-cumulative cache/speed totals behind the composer readout; null
+    // until the session has a call recorded.
+    usageReadout: session?.usageReadout || null,
   };
 }
 

package/src/runtime/agent/orchestrator/runtime-core/extension-scopes.mjs

@@ -48,12 +48,14 @@ export function filterMcpToolsForCwd(tools, scopes, cwd) {
   });
 }
 
-/** The MCP tools a session at `cwd` may see. No scopes configured → input
- *  returned as-is, so the global-only fast path costs one config read. */
+/** The MCP tools a session at `cwd` may see. No scopes configured → the input
+ *  as-is, so the global-only fast path costs one config read. An agent's
+ *  connectors never narrow this list: the schema and the BP2 manifest stay
+ *  identical across agents (one shared cache prefix), and the connector policy
+ *  is enforced at dispatch (pre-dispatch-deny / connector approval). */
 export function filterMcpToolsForSession(tools, cwd, config = null) {
   const list = Array.isArray(tools) ? tools : [];
   if (!list.length) return list;
   const scopes = extensionScopesFromConfig(config || loadConfig({ secrets: false }));
-  if (!hasExtensionScopes(scopes)) return list;
-  return filterMcpToolsForCwd(list, scopes, cwd);
+  return hasExtensionScopes(scopes) ? filterMcpToolsForCwd(list, scopes, cwd) : list;
 }

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

@@ -19,6 +19,18 @@ Lead executes all work directly and never delegates on its own judgment.
 Only when the user explicitly asks for delegation, load the deferred \`agent\`
 tool and brief each agent as the Lead rules describe.`;
 
+/** Agent mode's fixed delegation block, in place of the orchestration mode. */
+export const AGENT_MODE_DELEGATION = `# Delegation
+
+Handle conversation yourself. Delegate specialised work to sub-agents. Hand
+substantial coding to a new coding-mode task session (\`session create\`) with
+a self-contained brief: start it when already requested, otherwise suggest it. Then relay the
+result in your own words.`;
+
+/** Mixy only: it also routes requests to the user's contact agents. */
+export const MIXY_CONTACTS_INTRO = `You also coordinate the user's contact agents: route a request to the
+contact best suited for it with the same kind of brief.`;
+
 export function orchestrationInstructions(value) {
   const mode = normalizeOrchestrationMode(value);
   if (mode === 'none') return SOLO;
@@ -29,8 +41,7 @@ ${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.
+If the plan has only one implementation scope, Lead executes it directly.
 
 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
@@ -41,11 +52,7 @@ 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.
 A running agent receives only changes within its own scope; a new independent
 need goes to a new agent. When scopes touch the same file, name one owner for
-that file in each brief. Agents run only the checks covering their own change;
-Lead runs the full suite once after integration.
+that file in each brief.
 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.`;
+and never changes settings to enable one.`;
 }

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

@@ -23,6 +23,7 @@ const MCP_TRANSPORT_FIELDS = new Set([
   'env_http_headers',
   'env_vars',
   'autoDetect',
+  'oauthClientId',
 ]);
 
 // Every spelling resolveMcpStartupTimeoutMs / resolveMcpCallTimeoutMs reads.

package/src/runtime/agent/orchestrator/runtime-core/tool-bridge.mjs

@@ -14,6 +14,7 @@ import {
   deferredCatalogUnion,
   filterSessionToolPolicy,
   isReadonlySelectable,
+  mcpServerSelection,
   toolSearchMatches,
 } from './tool-catalog.mjs';
 import { parseToolSelection, sortedCatalogByMeasuredUsage } from './tool-catalog-schema.mjs';
@@ -249,8 +250,9 @@ function describeNames(raw) {
   return names;
 }
 
-// Requested names → available tools; an alias that names no tool expands to
-// its members (existing load_tool alias compatibility).
+// Requested names → available tools; an alias or `mcp__<server>` that names no
+// tool expands to its members (existing load_tool alias compatibility).
+// Definitions past the continuation target cap are listed as omitted.
 function resolveDescribeTargets(session, names, mode, available) {
   const eagerNames = eagerToolNames(session);
   const targets = [];
@@ -271,13 +273,15 @@ function resolveDescribeTargets(session, names, mode, available) {
       add(tool);
       continue;
     }
-    const members = (DEFERRED_SELECT_ALIASES[requested.toLowerCase()] || [])
+    const aliased = (DEFERRED_SELECT_ALIASES[requested.toLowerCase()] || [])
       .map((member) => lookupByName(available, member))
       .filter(Boolean);
+    const members = aliased.length ? aliased : mcpServerSelection(available, requested);
     if (members.length) members.forEach(add);
     else missing.push(requested);
   }
-  return { targets, missing, blocked };
+  const omitted = targets.splice(BRIDGE_LIMITS.continuationMaxTargets).map((tool) => clean(tool?.name));
+  return { targets, missing, blocked, omitted };
 }
 
 const SEARCH_MAX_MATCHES = 20;
@@ -367,6 +371,7 @@ export function describeBridgeTools(session, args = {}, { mode } = {}) {
   let missing = [];
   let blocked = [];
   let matches = [];
+  let omitted = [];
   if (continuation) {
     targets = continuationTargets(session, continuation.indexes, available, mode);
     if (!targets) return catalogChanged();
@@ -378,10 +383,11 @@ export function describeBridgeTools(session, args = {}, { mode } = {}) {
         `names must be 1-${BRIDGE_LIMITS.describeMaxNames} exact tool names of at most ${BRIDGE_LIMITS.nameMaxChars} characters.${syntaxHint}`
       );
     }
-    ({ targets, missing, blocked } = resolveDescribeTargets(session, names, mode, available));
+    ({ targets, missing, blocked, omitted } = resolveDescribeTargets(session, names, mode, available));
     ({ matches, missing } = searchKeywords(session, missing, mode, available));
   }
-  const found = matches.length ? { matches } : {};
+  // Omitted names are described by a later request naming them.
+  const found = { ...(matches.length ? { matches } : {}), ...(omitted.length ? { omitted } : {}) };
   const docs = targets.map((tool) => {
     const document = toolDocument(tool);
     return {

package/src/runtime/agent/orchestrator/runtime-core/tool-catalog.mjs

@@ -4,6 +4,8 @@
 import { clean } from './session-text.mjs';
 import { mergePendingDeferredToolDelta } from './deferred-tool-delta.mjs';
 import { applyInitialDeferredToolManifestToBp2 } from '../context/collect.mjs';
+import { listedDeferredToolNames } from '../context/deferred-tools.mjs';
+import { parseMcpToolName } from '../../../shared/tool-primitives.mjs';
 import { getMcpServerInstructionsMap, getMcpTools, getMcpToolGeneration } from '../mcp/client.mjs';
 import { filterMcpToolsForSession } from './extension-scopes.mjs';
 import { isDeferredToolAvailable, isToolPermittedBySessionPolicy } from './deferred-tool-availability.mjs';
@@ -259,6 +261,17 @@ function expandSelectionNames(names) {
   return [...new Set(out)];
 }
 
+/**
+ * The tools of `tools` that `mcp__<server>` stands for (the deferred manifest
+ * lists MCP servers, not their tools); [] for any other name. Callers try an
+ * exact tool name first.
+ */
+export function mcpServerSelection(tools, requested) {
+  const server = /^mcp__(.+)$/i.exec(clean(requested))?.[1]?.toLowerCase();
+  if (!server) return [];
+  return (tools || []).filter((tool) => String(parseMcpToolName(tool)?.server || '').toLowerCase() === server);
+}
+
 function storedDeferredToolNames(session) {
   for (const source of [session?.deferredDiscoveredTools, session?.deferredSelectedTools]) {
     const names = parseToolSelection(source);
@@ -430,8 +443,11 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
     // manifest, or the bridge roster + guidance. History stays as is.
     session.mcpServerInstructions = getMcpServerInstructionsMap(session.mcpScopeId);
     applyInitialDeferredToolManifestToBp2(session, deferredPoolToolNames(session), { rebuild: true });
-    const rendered = renderedDeferredManifest(session);
-    session.deferredAnnouncedTools = deferredPoolToolNames(session).filter((name) => rendered.includes(name));
+    session.deferredAnnouncedTools = listedDeferredToolNames(
+      session,
+      deferredPoolToolNames(session),
+      renderedDeferredManifest(session)
+    );
   }
   if (!session.deferredToolBp2Applied && session.messages?.some((m) => m?.role === 'system')) {
     if (!session.mcpServerInstructions || typeof session.mcpServerInstructions !== 'object') {
@@ -519,8 +535,11 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   // Pre-mark ONLY the names that ACTUALLY landed in the rebuilt BP2 manifest as
   // announced; anything the manifest could not advertise stays un-announced so
   // the turn-boundary late reminder can still surface it.
-  const rendered = renderedDeferredManifest(session);
-  session.deferredAnnouncedTools = deferredPoolToolNames(session).filter((name) => rendered.includes(name));
+  session.deferredAnnouncedTools = listedDeferredToolNames(
+    session,
+    deferredPoolToolNames(session),
+    renderedDeferredManifest(session)
+  );
   session.updatedAt = Date.now();
   return true;
 }
@@ -726,7 +745,15 @@ export function selectDeferredTools(session, names, mode, { exact = false } = {}
   const already = [];
   const blocked = [];
   const missing = [];
-  for (const rawName of exact ? [...new Set(names)] : expandSelectionNames(names)) {
+  const requested = exact
+    ? names
+    : expandSelectionNames(names).flatMap((raw) => {
+        const key = clean(raw);
+        if (byName.has(key) || byName.has(key.toLowerCase())) return [key];
+        const members = mcpServerSelection(catalog, key).map((tool) => clean(tool?.name));
+        return members.length ? members : [key];
+      });
+  for (const rawName of new Set(requested)) {
     const requestedName = clean(rawName);
     const tool = byName.get(requestedName) || byName.get(requestedName.toLowerCase());
     const name = clean(tool?.name);

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

@@ -17,7 +17,8 @@ export const TOOL_SEARCH_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Load full schemas for missing deferred tool names/aliases; batch needed names in one call.',
+  description:
+    'Load full schemas for missing deferred tool names/aliases; a connector name loads all its tools; batch needed names in one call.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -72,7 +73,7 @@ export const SESSION_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  trigger: 'Session lookup/control, title, compact, fork, Project and worktrees.',
+  trigger: 'Session lookup/control, coding task sessions, title, compact, fork, Project and worktrees.',
   description:
     'Inspect sessions or control another by exact ID, never a guessed one. send acknowledges queue intake, not completion. Cancel/delete and worktree actions require the user’s request. Other actions affect only the current session.',
   inputSchema: {
@@ -87,6 +88,7 @@ export const SESSION_TOOL = {
           'send',
           'cancel',
           'delete',
+          'create',
           'rename',
           'compact',
           'fork',
@@ -100,9 +102,9 @@ export const SESSION_TOOL = {
           'prune-worktrees',
         ],
         description:
-          'status defaults to current; list pages sessions; read returns latest items; send queues prompt; cancel stops the turn; delete removes the session. compact runs after this turn; fork copies it without switching. merge-worktree merges into the Project’s checked-out branch; remove-worktree returns to the Project (repeat on WORKTREE_REMOVAL_INCOMPLETE); list-worktrees includes retaining sessions; prune-worktrees removes only clean, merged, unretained worktrees.',
+          'status defaults to current; list pages sessions; read returns latest items; send queues prompt; cancel stops the turn; delete removes the session. create (agent conversations) starts a visible coding task session from brief and reports its turns back; unknown Project: list-projects first, still ambiguous: ask the user. compact runs after this turn; fork copies it without switching. merge-worktree merges into the Project’s checked-out branch; remove-worktree returns to the Project (repeat on WORKTREE_REMOVAL_INCOMPLETE); list-worktrees includes retaining sessions; prune-worktrees removes only clean, merged, unretained worktrees.',
       },
-      title: { type: 'string', description: 'rename: new current-session title.' },
+      title: { type: 'string', description: 'rename: new current-session title; create: task title.' },
       session_id: {
         type: 'string',
         description:
@@ -143,6 +145,10 @@ export const SESSION_TOOL = {
         description: 'remove-worktree: allow uncommitted/unmerged work only when explicitly requested.',
       },
       value: { type: 'boolean', description: 'favorite/archive: on or off.' },
+      brief: { type: 'string', description: 'create: self-contained instruction, the first message.' },
+      project: { type: 'string', description: 'create: registered Project name or existing directory.' },
+      model: { type: 'string', description: 'create: provider/model or preset; default route otherwise.' },
+      notify: { type: 'boolean', description: 'create: report results back, default true.' },
     },
     additionalProperties: false,
   },

package/src/runtime/agent/orchestrator/runtime-core/workflow/agents.mjs

@@ -29,7 +29,8 @@ function* scanCustomAgentIds(userRoot, shippedRoot) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const id = normalizeWorkflowId(entry.name);
-      if (!id || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
+      // `lead` is Mixy's own folder (PERSONA.md, AGENT.md), never an agent.
+      if (!id || id === 'lead' || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
       if (root !== userRoot && (yield { op: 'exists', path: join(userRoot, id, AGENT_DELETED_MARKER) })) continue;
       if (!(yield { op: 'exists', path: join(root, entry.name, 'AGENT.md') })) continue;
       ids.add(id);
@@ -101,6 +102,8 @@ export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, n
         permission: normalizeAgentPermissionOrNone(doc.frontmatter.permission),
         frontmatter: doc.frontmatter,
         body,
+        // Optional PERSONA.md beside AGENT.md (same dir, same cache entry).
+        persona: (readTextSafe(join(d, 'PERSONA.md')) || '').trim(),
       };
       setAgentDefinitionCache(cacheKey, definition);
       return definition;

package/src/runtime/agent/orchestrator/runtime-core/workflow/context.mjs

@@ -2,8 +2,8 @@
 // (active pack + orchestration instructions + delegatable agent catalog).
 import { clean } from '../session-text.mjs';
 import { configuredOrchestrationMode } from '../../../../shared/orchestration.mjs';
-import { orchestrationInstructions } from '../orchestration.mjs';
-import { DEFAULT_WORKFLOW_ID, normalizeWorkflowId } from '../workflow-ids.mjs';
+import { AGENT_MODE_DELEGATION, MIXY_CONTACTS_INTRO, orchestrationInstructions } from '../orchestration.mjs';
+import { DEFAULT_WORKFLOW_ID, isContactAgentId, normalizeWorkflowId } from '../workflow-ids.mjs';
 
 export function createWorkflowContext({ packs, agents }) {
   function workflowSummary(pack, { hasAgents = true } = {}) {
@@ -43,26 +43,53 @@ export function createWorkflowContext({ packs, agents }) {
     return lines.join('\n\n');
   }
 
-  function orchestrationContextBlock(config, dir) {
+  // Name + description only: the AGENT.md body is the worker's own system
+  // prompt and rides in the worker session at spawn time — repeating it in
+  // the Lead prompt only bloats context. Lead picks agents by description
+  // (a when-to-use signal); orchestration carries the delegation rules.
+  function agentCatalog(dir, ids) {
+    return ids
+      .map((id) => agents.loadAgentDefinition(dir, id))
+      .filter(Boolean)
+      .map((agent) => `- ${agent.name} (${agent.id})${agent.description ? `: ${agent.description}` : ''}`)
+      .join('\n');
+  }
+
+  // A Lead's workflow slices for BP3 (composeSystemPrompt orders them):
+  // - coding: the orchestration mode block and the full agent catalog;
+  // - agent mode: the fixed delegation block (no per-agent setting) and the
+  //   sub-agent catalog — identical for every agent, so their prompts share
+  //   it — plus, for Mixy only, the contact-agent catalog.
+  function leadPromptParts(config, dir, { agentMode = false, mixy = false } = {}) {
     const mode = configuredOrchestrationMode(config);
-    const agentIds = agents.delegatableAgentIds(config, dir);
-    // Solo without agents has nothing to delegate to on request either.
-    if (mode === 'none' && !agentIds.length) return '';
-    const lines = [orchestrationInstructions(mode)];
-    const agentBlocks = agentIds.map((id) => agents.loadAgentDefinition(dir, id)).filter(Boolean);
-    if (agentBlocks.length) {
-      lines.push('# Available Agents');
-      // Name + description only: the AGENT.md body is the worker's own system
-      // prompt and rides in the worker session at spawn time — repeating it in
-      // the Lead prompt only bloats context. Lead picks agents by description
-      // (a when-to-use signal); orchestration carries the delegation rules.
-      lines.push(
-        agentBlocks
-          .map((agent) => `- ${agent.name} (${agent.id})${agent.description ? `: ${agent.description}` : ''}`)
-          .join('\n')
-      );
+    const ids = agents.delegatableAgentIds(config, dir);
+    if (!agentMode) {
+      const catalog = agentCatalog(dir, ids);
+      return {
+        // Solo without agents has nothing to delegate to on request either.
+        orchestrationContext: mode === 'none' && !ids.length ? '' : orchestrationInstructions(mode),
+        agentCatalogContext: catalog ? `# Available Agents\n\n${catalog}` : '',
+        contactCatalogContext: '',
+      };
     }
-    return lines.join('\n\n');
+    const isContact = (id) => isContactAgentId(id, agents.loadAgentDefinition(dir, id)?.frontmatter?.kind);
+    const subAgents = agentCatalog(
+      dir,
+      ids.filter((id) => !isContact(id))
+    );
+    const contacts = mixy ? agentCatalog(dir, ids.filter(isContact)) : '';
+    return {
+      // An agent-mode Lead without agents has no one to delegate to at all.
+      orchestrationContext: subAgents || contacts ? AGENT_MODE_DELEGATION : '',
+      agentCatalogContext: subAgents ? `# Available Agents\n\n${subAgents}` : '',
+      contactCatalogContext: contacts ? `# Contact Agents\n\n${MIXY_CONTACTS_INTRO}\n\n${contacts}` : '',
+    };
+  }
+
+  // The coding Lead's combined block (orchestration + catalog), as before.
+  function orchestrationContextBlock(config, dir) {
+    const { orchestrationContext, agentCatalogContext } = leadPromptParts(config, dir);
+    return [orchestrationContext, agentCatalogContext].filter(Boolean).join('\n\n');
   }
 
   // Single-pass variant: loads the active WORKFLOW.md pack once and derives both
@@ -81,6 +108,9 @@ export function createWorkflowContext({ packs, agents }) {
       // orchestration instructions / agent catalog.
       packContext,
       context: [packContext, orchestrationContextBlock(config, dir)].filter(Boolean).join('\n\n'),
+      // A Lead's BP3 slices beside the pack: `{ agentMode, mixy }` picks the
+      // coding, agent or Mixy variant (session/agent-mode.mjs).
+      leadPromptParts: (options) => leadPromptParts(config, dir, options),
     };
   }
 

package/src/runtime/agent/orchestrator/runtime-core/workflow-ids.mjs

@@ -15,6 +15,8 @@ export const BUILTIN_SLOT_AGENT_IDS = new Set(
   FIXED_AGENT_SLOTS.filter((agent) => agent.workflowSlot).map((agent) => agent.id)
 );
 export const STARTER_AGENT_ORDER = new Map(DEFAULT_DISABLED_AGENT_IDS.map((id, index) => [id, index]));
+// Only Mixy delegates to contacts (agent-route-config.mjs isContactAgentId).
+export { isContactAgentId } from '../../../shared/agent-route-config.mjs';
 export const DEFAULT_WORKFLOW_ID = 'default';
 
 // Loaded AGENT.md definitions, keyed `${dir}\n${agentId}`.