nexus-prime 7.9.22 → 7.9.24

package/dist/agents/adapters/ide-compat.d.ts

@@ -2,10 +2,10 @@
  * Nexus Prime — IDE Compatibility Utilities
  * Provides MCP config templates and detection logic for all supported IDEs.
  *
- * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex
+ * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex, and peer agent clients.
  */
-export type IDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'cline' | 'zed' | 'codex';
-export type CallerIDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'zed' | 'codex';
+export type IDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'cline' | 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'zed' | 'codex';
+export type CallerIDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'zed' | 'codex';
 export interface McpConfigOutput {
     /** Absolute path where the config should be written */
     configPath: string | null;

package/dist/agents/adapters/ide-compat.js

@@ -2,7 +2,7 @@
  * Nexus Prime — IDE Compatibility Utilities
  * Provides MCP config templates and detection logic for all supported IDEs.
  *
- * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex
+ * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex, and peer agent clients.
  */
 import { existsSync } from 'fs';
 import { homedir } from 'os';
@@ -29,6 +29,18 @@ function detectCallerIDEFromEnv() {
     if (hasAnyEnvPrefix('WINDSURF_')) {
         return 'windsurf';
     }
+    if (hasAnyEnvPrefix('OPENCLAW_') || hasAnyEnvPrefix('ANTIGRAVITY_')) {
+        return 'openclaw';
+    }
+    if (hasAnyEnvPrefix('HERMES_')) {
+        return 'hermes';
+    }
+    if (hasAnyEnvPrefix('NANOCLAW_')) {
+        return 'nanoclaw';
+    }
+    if (hasAnyEnvPrefix('PICOCLAW_')) {
+        return 'picoclaw';
+    }
     if (hasAnyEnvPrefix('CONTINUE_')) {
         return 'continue';
     }
@@ -46,6 +58,14 @@ function detectCallerIDEFromFilesystem(startDir) {
             return 'continue';
         if (existsSync(join(current, '.windsurf')))
             return 'windsurf';
+        if (existsSync(join(current, '.openclaw')))
+            return 'openclaw';
+        if (existsSync(join(current, '.hermes')))
+            return 'hermes';
+        if (existsSync(join(current, '.nanoclaw')))
+            return 'nanoclaw';
+        if (existsSync(join(current, '.picoclaw')))
+            return 'picoclaw';
         if (existsSync(join(current, '.zed')))
             return 'zed';
         const parent = dirname(current);
@@ -84,6 +104,22 @@ export function detectInstalledIDEs(workspaceRoot) {
         existsSync(join(home, '.windsurf'))) {
         detected.push('windsurf');
     }
+    if (existsSync(join(workspaceRoot, '.openclaw')) ||
+        existsSync(join(home, '.openclaw'))) {
+        detected.push('openclaw');
+    }
+    if (existsSync(join(workspaceRoot, '.hermes')) ||
+        existsSync(join(home, '.hermes'))) {
+        detected.push('hermes');
+    }
+    if (existsSync(join(workspaceRoot, '.nanoclaw')) ||
+        existsSync(join(home, '.nanoclaw'))) {
+        detected.push('nanoclaw');
+    }
+    if (existsSync(join(workspaceRoot, '.picoclaw')) ||
+        existsSync(join(home, '.picoclaw'))) {
+        detected.push('picoclaw');
+    }
     // Continue.dev: .continue/ directory
     if (existsSync(join(workspaceRoot, '.continue')) ||
         existsSync(join(home, '.continue'))) {
@@ -140,6 +176,20 @@ export function getMcpConfigForIDE(ide, workspaceRoot) {
             }, null, 2);
             return { configPath, content, merge: true };
         }
+        case 'openclaw':
+        case 'hermes':
+        case 'nanoclaw':
+        case 'picoclaw': {
+            const configPath = ide === 'openclaw'
+                ? join(home, '.openclaw', 'openclaw.json')
+                : join(home, `.${ide}`, 'mcp.json');
+            const content = JSON.stringify({
+                mcpServers: {
+                    'nexus-prime': entry,
+                },
+            }, null, 2);
+            return { configPath, content, merge: true };
+        }
         case 'continue': {
             // Continue.dev uses ~/.continue/config.json
             const configPath = join(home, '.continue', 'config.json');

package/dist/agents/adapters/mcp/definitions.js

@@ -279,7 +279,10 @@ export function buildMcpToolDefinitions() {
                     crews: { type: 'array', items: { type: 'string' }, description: 'Optional hard crew selectors' },
                     specialists: { type: 'array', items: { type: 'string' }, description: 'Optional hard specialist selectors' },
                     optimizationProfile: { type: 'string', enum: ['standard', 'max'], description: 'Planner optimization profile override' },
-                    executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset that maps orchestration depth, verification strictness, and backend routing' }
+                    executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset that maps orchestration depth, verification strictness, and backend routing' },
+                    background: { type: 'boolean', description: 'When true, return a queued receipt immediately and let the run continue in the async gate.' },
+                    async: { type: 'boolean', description: 'Alias for background; useful for clients that prefer explicit async orchestration.' },
+                    waitMs: { type: 'number', description: 'Optional bounded wait before returning a queued receipt. Clamped to 45 seconds; normal orchestrate calls default to 15 seconds.' }
                 },
                 required: ['prompt'],
             },

package/dist/agents/adapters/mcp/dispatch.js

@@ -16,9 +16,19 @@ import { handleMiscGroup } from './handlers/misc.js';
 import { handleWorkforceGroup } from './handlers/workforce.js';
 import { nexusEventBus } from '../../../engines/event-bus.js';
 import { recordToolInvocation } from './tool-health.js';
-import { withAsyncGate } from './async-gate.js';
+import { getAsyncGate, withAsyncGate } from './async-gate.js';
 import { getCircuitManager, checkBackpressure } from './circuit.js';
-import { createRun } from '../../../engines/orchestrator/store.js';
+import { completeRun, createRun, failRun, updateStage } from '../../../engines/orchestrator/store.js';
+import { buildSelectionPlan } from '../../../engines/orchestrator/decision-spine.js';
+function summarizeAsyncMcpResult(toolName, result) {
+    const text = result?.content
+        ?.map((part) => part?.type === 'text' ? String(part.text ?? '') : '')
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+    const firstLine = text?.split('\n').find((line) => line.trim())?.trim();
+    return (firstLine ? `${toolName}: ${firstLine}` : `${toolName} completed asynchronously`).slice(0, 1024);
+}
 /** Tools that may exceed the MCP client timeout (~60s). Wrap in async gate. */
 const SLOW_TOOLS = new Set([
     'nexus_orchestrate',
@@ -69,6 +79,183 @@ const TOOL_ETA_MS = {
     nexus_autofix: 45_000,
     nexus_hypertune_max: 45_000,
 };
+const DEFAULT_MAX_SYNC_MS = 2000;
+const ORCHESTRATE_DEFAULT_MAX_SYNC_MS = 15_000;
+const MAX_CLIENT_SYNC_WAIT_MS = 45_000;
+function isTruthyFlag(value) {
+    if (value === true)
+        return true;
+    if (typeof value === 'number')
+        return value > 0;
+    if (typeof value === 'string')
+        return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+    return false;
+}
+function coerceBoundedWaitMs(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0)
+        return undefined;
+    return Math.min(MAX_CLIENT_SYNC_WAIT_MS, Math.floor(numeric));
+}
+function shouldReturnQueuedReceipt(toolName, args) {
+    if (!SLOW_TOOLS.has(toolName))
+        return false;
+    return isTruthyFlag(args.background)
+        || isTruthyFlag(args.async)
+        || isTruthyFlag(args.queue)
+        || isTruthyFlag(args.detach);
+}
+function resolveMaxSyncMs(toolName, args) {
+    return coerceBoundedWaitMs(args.waitMs)
+        ?? coerceBoundedWaitMs(args.maxSyncMs)
+        ?? (toolName === 'nexus_orchestrate' ? ORCHESTRATE_DEFAULT_MAX_SYNC_MS : DEFAULT_MAX_SYNC_MS);
+}
+function asStringList(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => typeof item === 'string' ? item : (item && typeof item === 'object' ? String(item.name ?? item.id ?? '') : String(item ?? '')))
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    if (typeof value === 'string') {
+        return value.split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+function uniqueList(items, max = 8) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const value = String(item ?? '').trim();
+        if (!value || seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+function extractLinkedSelectors(prompt, prefix) {
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`\\[${escaped}([^\\]\\s]+)\\]`, 'g');
+    return Array.from(prompt.matchAll(pattern))
+        .map((match) => match[1]?.trim())
+        .filter(Boolean);
+}
+function inferQueuedOrchestratePreview(args, runId) {
+    const prompt = String(args.prompt ?? args.goal ?? '');
+    const lower = prompt.toLowerCase();
+    const files = uniqueList([
+        ...asStringList(args.files),
+        ...asStringList(args.filePaths),
+    ], 20);
+    const skills = uniqueList([
+        ...asStringList(args.skills),
+        ...asStringList(args.skillNames),
+        ...extractLinkedSelectors(prompt, '$'),
+    ], 20);
+    const workflows = uniqueList([
+        ...asStringList(args.workflows),
+        ...asStringList(args.workflowSelectors),
+        lower.match(/orchestrat|route|dispatch|queue|queued/) ? 'orchestration-runtime-workflow' : undefined,
+        lower.match(/synapse|hiring|operative|sortie/) ? 'synapse-mandate-workflow' : undefined,
+        lower.match(/memory|recall|learning|decay|graph/) ? 'memory-lifecycle-workflow' : undefined,
+        lower.match(/token|budget|optim/i) ? 'token-budget-workflow' : undefined,
+        lower.match(/dashboard|board|ui|ux/) ? 'dashboard-observability-workflow' : undefined,
+    ], 8);
+    const specialists = uniqueList([
+        ...asStringList(args.specialists),
+        lower.match(/orchestrat|route|dispatch|queue|queued/) ? 'Orchestrator Runtime Engineer' : undefined,
+        lower.match(/synapse|hiring|operative|sortie/) ? 'Synapse Runtime Engineer' : undefined,
+        lower.match(/memory|recall|learning|decay|graph/) ? 'Memory Systems Engineer' : undefined,
+        lower.match(/token|budget|optim/i) ? 'Token Budget Engineer' : undefined,
+        lower.match(/dashboard|board|ui|ux/) ? 'Dashboard UX Engineer' : undefined,
+        lower.match(/test|verify|qa|release|publish/) ? 'Verification Engineer' : undefined,
+    ], 8);
+    const crew = String(args.crew ?? args.selectedCrew ?? (lower.match(/orchestrat|synapse|runtime|mcp|dispatch|queue|queued/)
+        ? 'Runtime Reliability Crew'
+        : lower.match(/memory|token|dashboard/)
+            ? 'Control Plane Quality Crew'
+            : 'Nexus Implementation Crew'));
+    const risk = lower.match(/fix|broken|bug|doesn.?t|failed|queued|runtime|synapse|orchestrat/) ? 'high' : 'medium';
+    const task = {
+        goal: prompt,
+        intent: lower.match(/fix|bug|broken|doesn.?t|failed/) ? 'bugfix' : 'feature',
+        files,
+        skillNames: skills,
+        workflowSelectors: workflows,
+    };
+    const workerManifests = uniqueList([
+        specialists.length > 0 ? 'worker_coder' : undefined,
+        'worker_verifier',
+    ]).map((workerId, index) => ({
+        workerId,
+        role: index === 0 ? 'coder' : 'verifier',
+        specialistName: index === 0 ? specialists[0] : 'Verification Engineer',
+        actions: index === 0 ? ['inspect', 'patch'] : ['verify'],
+        verifyCommands: index === 1 ? ['npm run lint', 'targeted tests'] : [],
+    }));
+    const run = {
+        runId,
+        requestBrief: {
+            id: `brief_${runId}`,
+            intent: task.intent,
+            risk,
+            confidence: 0.68,
+        },
+        plannerResult: {
+            selectedFiles: files,
+            selectedSkills: skills,
+            selectedWorkflows: workflows,
+            selectedSpecialists: specialists.map((name) => ({ name })),
+            selectedCrew: { name: crew },
+        },
+        workerManifests,
+    };
+    const plan = buildSelectionPlan({ run, task });
+    return { plan, crew, specialists, workflows };
+}
+function formatBudgetRoute(plan) {
+    const total = Number(plan.budgets?.total ?? 0);
+    const code = Number(plan.budgets?.codeBlocks ?? plan.budgets?.codeBlockPolicy?.reservedTokens ?? 0);
+    const cap = Number(plan.executionPolicy?.agentFlow?.maxTaskCostUsd ?? plan.executionPolicy?.budgetCapUsd ?? 0);
+    return `${total.toLocaleString()} tokens · ${code.toLocaleString()} code-block tokens · $${cap.toFixed(2)} task cap`;
+}
+function formatQueuedOrchestrateReceipt(args, receipt) {
+    const preview = inferQueuedOrchestratePreview(args, receipt.runId);
+    const plan = preview.plan;
+    const stages = Array.isArray(plan.executionPolicy?.agentFlow?.stages)
+        ? plan.executionPolicy.agentFlow.stages
+        : [];
+    const selected = plan.selected ?? {};
+    const specialists = uniqueList([...(selected.specialists ?? []), ...preview.specialists], 8);
+    const workflows = uniqueList([...(selected.workflows ?? []), ...preview.workflows], 8);
+    const skills = uniqueList(selected.skills ?? [], 8);
+    const receiptJson = JSON.stringify({ queued: true, runId: receipt.runId, etaMs: receipt.etaMs }, null, 2);
+    const hiredLine = [
+        `crew ${preview.crew}`,
+        specialists.length ? `specialists ${specialists.join(', ')}` : '',
+        workflows.length ? `workflows ${workflows.join(', ')}` : '',
+        skills.length ? `skills ${skills.join(', ')}` : '',
+    ].filter(Boolean).join(' · ');
+    return [
+        'Nexus orchestration queued with hiring preflight.',
+        `Run: ${receipt.runId}`,
+        `ETA: ${receipt.etaMs ? `~${Math.ceil(receipt.etaMs / 1000)}s` : 'background'}`,
+        `Hired/selected: ${hiredLine}`,
+        `Model route: ${plan.modelRoute?.workerTier ?? 'T1'}${plan.modelRoute?.reviewerTier ? ` + reviewer ${plan.modelRoute.reviewerTier}` : ''}`,
+        `Budget route: ${formatBudgetRoute(plan)}`,
+        stages.length ? `AgentFlow gates: ${stages.map((stage) => `${stage.stage}:${stage.ownerRole}`).join(' -> ')}` : '',
+        'Poll progress with nexus_run_status(runId).',
+        '',
+        '```json',
+        receiptJson,
+        '```',
+    ].filter((line) => line !== '').join('\n');
+}
 /**
  * Route a tool call to the appropriate handler group.
  *
@@ -127,9 +314,9 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
             }, {
                 tool: toolName,
                 args,
-                maxSyncMs: 2000,
+                maxSyncMs: resolveMaxSyncMs(toolName, args),
                 etaMs: TOOL_ETA_MS[toolName],
-                alwaysQueue: toolName === 'nexus_orchestrate',
+                alwaysQueue: shouldReturnQueuedReceipt(toolName, args),
             });
             if ('queued' in gated && gated.queued) {
                 // Persist orchestration run record for durable stage tracking
@@ -138,6 +325,7 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                     const client = hctx.getToolProfile();
                     try {
                         createRun(gated.runId, goal, client);
+                        updateStage(gated.runId, 'executing', 20);
                     }
                     catch { /* non-fatal */ }
                 }
@@ -147,8 +335,24 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                 const runId = gated.runId;
                 let unsubOk = null;
                 let unsubFail = null;
+                let finalized = false;
                 const finalize = (success) => {
+                    if (finalized)
+                        return;
+                    finalized = true;
                     const durationMs = Date.now() - startedAt;
+                    if (toolName === 'nexus_orchestrate') {
+                        try {
+                            const job = getAsyncGate().getJob(runId);
+                            if (success) {
+                                completeRun(runId, summarizeAsyncMcpResult(toolName, job?.result));
+                            }
+                            else {
+                                failRun(runId, job?.error ?? `${toolName} failed asynchronously`);
+                            }
+                        }
+                        catch { /* durable run updates are best-effort */ }
+                    }
                     try {
                         circuit.recordComplete(toolName, durationMs, success);
                     }
@@ -166,12 +370,19 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                     if (ev.runId === runId)
                         finalize(false);
                 });
+                const existingJob = getAsyncGate().getJob(runId);
+                if (existingJob?.status === 'completed')
+                    finalize(true);
+                if (existingJob?.status === 'failed')
+                    finalize(false);
                 // Return async receipt as MCP text so agent can poll
                 rawResult = {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify({ queued: true, runId: gated.runId, etaMs: gated.etaMs }, null, 2)
-                                + '\n\nCall nexus_run_status(runId) to check progress.',
+                            text: toolName === 'nexus_orchestrate'
+                                ? formatQueuedOrchestrateReceipt(args, gated)
+                                : JSON.stringify({ queued: true, runId: gated.runId, etaMs: gated.etaMs }, null, 2)
+                                    + '\n\nCall nexus_run_status(runId) to check progress.',
                         }],
                 };
             }

package/dist/agents/adapters/mcp/handlers/orchestration.js

@@ -55,6 +55,82 @@ export function extractSkillSelectorsFromPrompt(prompt) {
 export function inferSpawnWorkersIntent(actions) {
     return actions.length > 0 ? 'mutate' : 'plan';
 }
+function namedValue(value) {
+    if (typeof value === 'string')
+        return value.trim();
+    if (!value || typeof value !== 'object')
+        return '';
+    const record = value;
+    return String(record.name ?? record.id ?? record.specialistId ?? record.skillId ?? record.workflowId ?? record.crewId ?? record.workerId ?? '').trim();
+}
+function asStringList(values, limit = 8) {
+    const array = Array.isArray(values) ? values : values ? [values] : [];
+    return [...new Set(array.map(namedValue).filter(Boolean))].slice(0, limit);
+}
+function formatSelectionList(values, fallback = 'none') {
+    return values.length > 0 ? values.join(', ') : fallback;
+}
+function formatModelRoute(route) {
+    if (!route)
+        return 'default runtime route';
+    const worker = String(route.workerTier ?? 'T1');
+    const reviewer = route.reviewerTier ? ` + reviewer ${route.reviewerTier}` : '';
+    const reason = route.reason ? ` - ${route.reason}` : '';
+    return `${worker}${reviewer}${reason}`;
+}
+function formatBudgetRoute(plan) {
+    const budgets = plan?.budgets ?? {};
+    const policy = plan?.executionPolicy?.agentFlow ?? {};
+    const total = Number(budgets.totalTokens ?? 0);
+    const codeBlocks = Number(budgets.codeBlocks ?? budgets.codeBlockPolicy?.reservedTokens ?? 0);
+    const cap = Number(policy.maxTaskCostUsd ?? 0);
+    const parts = [
+        total > 0 ? `${total.toLocaleString()} tokens` : 'budget pending',
+        codeBlocks > 0 ? `${codeBlocks.toLocaleString()} code-block tokens` : null,
+        cap > 0 ? `$${cap.toFixed(2)} task cap` : null,
+    ].filter(Boolean);
+    return parts.join(' · ');
+}
+function buildSelectionSummary(execution, runtimeUsage) {
+    const selectionPlan = execution.selectionPlan ?? {};
+    const selected = selectionPlan.selected ?? {};
+    const planner = execution.plannerState ?? {};
+    const taskGraph = runtimeUsage.taskGraph ?? execution.taskGraph ?? {};
+    const workerPlan = runtimeUsage.workerPlan ?? execution.workerPlan ?? {};
+    const audit = runtimeUsage.artifactSelectionAudit ?? execution.artifactSelectionAudit ?? {};
+    const crew = asStringList(selected.crews, 2)[0]
+        ?? namedValue(planner.selectedCrew)
+        ?? 'baseline path';
+    const specialists = asStringList(selected.specialists, 8).length > 0
+        ? asStringList(selected.specialists, 8)
+        : asStringList(planner.selectedSpecialists, 8);
+    const skills = asStringList(selected.skills, 8).length > 0
+        ? asStringList(selected.skills, 8)
+        : asStringList(execution.activeSkills, 8).concat(asStringList(planner.selectedSkills, 8)).slice(0, 8);
+    const workflows = asStringList(selected.workflows, 8).length > 0
+        ? asStringList(selected.workflows, 8)
+        : asStringList(execution.activeWorkflows, 8).concat(asStringList(planner.selectedWorkflows, 8)).slice(0, 8);
+    const workers = asStringList(selected.workers, 8).length > 0
+        ? asStringList(selected.workers, 8)
+        : asStringList(execution.workerManifests, 8);
+    return {
+        crew,
+        specialists,
+        skills: [...new Set(skills)],
+        workflows: [...new Set(workflows)],
+        hooks: asStringList(selected.hooks, 8),
+        automations: asStringList(selected.automations, 8),
+        workers,
+        modelRoute: selectionPlan.modelRoute ?? execution.requestBrief?.modelPolicy,
+        budgetRoute: formatBudgetRoute(selectionPlan),
+        agentFlow: selectionPlan.executionPolicy?.agentFlow,
+        phaseCount: Array.isArray(taskGraph.phases) ? taskGraph.phases.length : 0,
+        workerLaneCount: Number(workerPlan.totalWorkers ?? workers.length ?? execution.workerResults?.length ?? 0),
+        mode: String(workerPlan.mode ?? execution.mode ?? 'autonomous'),
+        auditSelected: Array.isArray(audit.selected) ? audit.selected.length : 0,
+        auditRejected: Array.isArray(audit.rejected) ? audit.rejected.length : 0,
+    };
+}
 export async function handleOrchestrationGroup(toolName, hctx, request, args, ctx) {
     const runtimeError = requireRuntime(hctx);
     if (runtimeError)
@@ -457,6 +533,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     result.modifiedFiles.forEach((file) => hctx.sessionDNA.recordFileModified(file));
                 });
                 const runtimeUsage = hctx.getRuntime().getUsageSnapshot();
+                const selectionSummary = buildSelectionSummary(execution, runtimeUsage);
                 hctx.sessionDNA.recordDecision('Orchestrated autonomous run completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.95
                     : execution.state === 'inspected' ? 0.85
                         : execution.state === 'rolled_back' ? 0.55
@@ -491,6 +568,8 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     worktreeHealth: runtimeUsage.worktreeHealth,
                     ragUsageSummary: runtimeUsage.ragUsageSummary ?? execution.ragUsageSummary,
                     memoryScopeUsage: runtimeUsage.memoryScopeUsage ?? execution.memoryScopeUsage,
+                    selection: selectionSummary,
+                    modelRoute: selectionSummary.modelRoute,
                     verifiedWorkers,
                     continuationChildren: execution.continuationChildren.length,
                     executionPreset: preset ? { id: preset.id, name: preset.name, summary: preset.summary } : undefined,
@@ -525,6 +604,10 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     ragUsageSummary: runtimeUsage.ragUsageSummary ?? execution.ragUsageSummary,
                     memoryScopeUsage: runtimeUsage.memoryScopeUsage ?? execution.memoryScopeUsage,
                     memoryReconciliationSummary: runtimeUsage.memoryReconciliationSummary ?? execution.memoryReconciliationSummary,
+                    requestBrief: execution.requestBrief,
+                    selectionPlan: execution.selectionPlan,
+                    selection: selectionSummary,
+                    modelRoute: selectionSummary.modelRoute,
                     tokens: execution.tokenTelemetry,
                     verifiedWorkers,
                     continuationChildren: execution.continuationChildren,
@@ -545,6 +628,14 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                     `Run ID: ${execution.runId}`,
                                     `Summary: ${summarizeExecution(execution)}`,
                                     `Crew: ${execution.plannerState?.selectedCrew?.name || 'baseline path'}`,
+                                    `Decomposition: ${selectionSummary.phaseCount} phase(s), ${selectionSummary.workerLaneCount} worker lane(s), ${selectionSummary.mode}`,
+                                    `Hired/selected: crew ${selectionSummary.crew}; specialists ${formatSelectionList(selectionSummary.specialists)}; workflows ${formatSelectionList(selectionSummary.workflows)}; skills ${formatSelectionList(selectionSummary.skills)}`,
+                                    `Model route: ${formatModelRoute(selectionSummary.modelRoute)}`,
+                                    `Budget route: ${selectionSummary.budgetRoute || 'budget pending'}`,
+                                    selectionSummary.agentFlow?.stages?.length
+                                        ? `AgentFlow gates: ${selectionSummary.agentFlow.stages.map((stage) => `${stage.stage}:${stage.ownerRole}`).join(' -> ')}`
+                                        : null,
+                                    `Selection audit: ${selectionSummary.auditSelected} selected, ${selectionSummary.auditRejected} rejected`,
                                     `Verification: ${verifiedWorkers}/${execution.workerResults.length} worker(s) verified`,
                                     `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}%`,
                                     autoTokenApplyNote || null,

package/dist/agents/adapters/mcp/runHandler.js

@@ -21,6 +21,9 @@ const CLIENT_TIMEOUTS = {
     'claude-code': 60_000,
     'cursor': 30_000,
     'openclaw': 90_000,
+    'hermes': 90_000,
+    'nanoclaw': 90_000,
+    'picoclaw': 90_000,
     'opencode': 90_000,
     'windsurf': 90_000,
     'antigravity': 90_000,

package/dist/agents/adapters/mcp/util/detect-caller.js

@@ -17,6 +17,9 @@ const ENV_MAP = [
     [['CURSOR_HOME', 'CURSOR_SESSION'], 'cursor'],
     [['OPENCODE_HOME'], 'opencode'],
     [['WINDSURF_HOME', 'WINDSURF_SESSION'], 'windsurf'],
+    [['HERMES_HOME', 'HERMES_SESSION'], 'hermes'],
+    [['NANOCLAW_HOME', 'NANOCLAW_SESSION'], 'nanoclaw'],
+    [['PICOCLAW_HOME', 'PICOCLAW_SESSION'], 'picoclaw'],
 ];
 // Module-level store for the caller name obtained from the MCP initialize
 // handshake.  Takes precedence over env-var and ps fallback once set.
@@ -52,6 +55,18 @@ export function setMcpClientName(rawName) {
         _mcpHandshakeName = 'windsurf';
         return;
     }
+    if (lower.includes('hermes')) {
+        _mcpHandshakeName = 'hermes';
+        return;
+    }
+    if (lower.includes('nanoclaw') || lower.includes('nano-claw')) {
+        _mcpHandshakeName = 'nanoclaw';
+        return;
+    }
+    if (lower.includes('picoclaw') || lower.includes('pico-claw')) {
+        _mcpHandshakeName = 'picoclaw';
+        return;
+    }
     if (lower.includes('anticlaw') || lower.includes('openclaw')) {
         _mcpHandshakeName = 'openclaw';
         return;
@@ -95,6 +110,12 @@ export async function detectCallerAsync() {
             return 'opencode';
         if (ps.includes('windsurf'))
             return 'windsurf';
+        if (ps.includes('hermes'))
+            return 'hermes';
+        if (ps.includes('nanoclaw') || ps.includes('nano-claw'))
+            return 'nanoclaw';
+        if (ps.includes('picoclaw') || ps.includes('pico-claw'))
+            return 'picoclaw';
         if (ps.includes('antigravity') || ps.includes('openclaw'))
             return 'openclaw';
     }

package/dist/agents/adapters/mcp.js

@@ -719,7 +719,7 @@ export class MCPAdapter {
                 try {
                     this.getRuntime().recordClientInstructionStatus({
                         clientId: this.name,
-                        clientFamily: this.name === 'openclaw' ? 'antigravity' : this.name,
+                        clientFamily: this.name === 'openclaw' || this.name === 'antigravity' ? 'antigravity' : this.name,
                         toolProfile: profile,
                         status: profile === 'autonomous' ? 'guided' : 'manual',
                         summary: this.describeClientInstructionStatus(profile),

package/dist/agents/adapters.d.ts

@@ -24,6 +24,15 @@ declare abstract class RenderedInstructionAdapter implements Adapter {
 export declare class OpenClawAdapter extends RenderedInstructionAdapter {
     constructor();
 }
+export declare class HermesAdapter extends RenderedInstructionAdapter {
+    constructor();
+}
+export declare class NanoClawAdapter extends RenderedInstructionAdapter {
+    constructor();
+}
+export declare class PicoClawAdapter extends RenderedInstructionAdapter {
+    constructor();
+}
 export declare class ClaudeCodeAdapter extends RenderedInstructionAdapter {
     constructor();
 }
@@ -60,5 +69,5 @@ export declare class CustomAdapter extends RenderedInstructionAdapter {
     setSendHandler(handler: (message: NetworkMessage) => Promise<void>): void;
     setReceiveHandler(handler: (message: NetworkMessage) => void): void;
 }
-export type AdapterType = 'openclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
+export type AdapterType = 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
 export declare function createAdapter(type: AdapterType, customName?: string): Adapter;

package/dist/agents/adapters.js

@@ -78,6 +78,21 @@ export class OpenClawAdapter extends RenderedInstructionAdapter {
         super('openclaw', 'openclaw');
     }
 }
+export class HermesAdapter extends RenderedInstructionAdapter {
+    constructor() {
+        super('hermes', 'hermes');
+    }
+}
+export class NanoClawAdapter extends RenderedInstructionAdapter {
+    constructor() {
+        super('nanoclaw', 'nanoclaw');
+    }
+}
+export class PicoClawAdapter extends RenderedInstructionAdapter {
+    constructor() {
+        super('picoclaw', 'picoclaw');
+    }
+}
 export class ClaudeCodeAdapter extends RenderedInstructionAdapter {
     constructor() {
         super('claude-code', 'claude-code');
@@ -158,6 +173,12 @@ export function createAdapter(type, customName) {
     switch (type) {
         case 'openclaw':
             return new OpenClawAdapter();
+        case 'hermes':
+            return new HermesAdapter();
+        case 'nanoclaw':
+            return new NanoClawAdapter();
+        case 'picoclaw':
+            return new PicoClawAdapter();
         case 'claude-code':
             return new ClaudeCodeAdapter();
         case 'ruflo':

package/dist/agents/core/types.d.ts

@@ -146,7 +146,7 @@ export interface EvolutionConfig {
 }
 export interface Adapter {
     name: string;
-    type: 'openclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
+    type: 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
     connected: boolean;
     agents: string[];
     connect(): Promise<void>;